Module Contents

open fun getKeys(): MutableList<String!>!

open class AboutQueryResponse

Module Contents

AboutQueryResponse()

AboutQueryResponse(name: String!)

abstract class AbstractBytes :

Module Contents

AbstractBytes()

Module Contents

balance

storageRoot

codeHash

)

balance

storageRoot

codeHash

version

Int

)

)

fun getStorageRoot():

fun getVersion(): Int

Module Contents

)

static fun fromPublicKey(publicKey: PublicKey!):

static fun fromPublicKeyBytes(bytes:

)

object AES128GCM

Module Contents

fun decrypt(privateKey:

nonce

encoded

additionalAuthenticatedData

)

fun encrypt(privateKey:

nonce

message

additionalAuthenticatedData

)

class AES256GCM : AutoCloseable

Module Contents

nonce

Nonce

)

@Nullable fun decrypt(cipherText: ByteArray!, nonce: Nonce!): ByteArray?

data

nonce

Nonce

)

@Nullable fun decrypt(cipherText: ByteArray!, data: ByteArray!, nonce: Nonce!): ByteArray?

key

Key

nonce

Nonce

)

@Nullable static fun decrypt(cipherText: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

data

key

Key

nonce

Nonce

)

@Nullable static fun decrypt(cipherText: ByteArray!, data: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

mac

nonce

Nonce

)

@Nullable fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, nonce: Nonce!): ByteArray?

mac

data

nonce

Nonce

)

@Nullable fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, data: ByteArray!, nonce: Nonce!): ByteArray?

mac

key

Key

nonce

Nonce

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

mac

data

key

Key

nonce

Nonce

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, data: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

nonce

Nonce

)

fun encrypt(message: ByteArray!, nonce: Nonce!): ByteArray!

data

nonce

Nonce

)

fun encrypt(message: ByteArray!, data: ByteArray!, nonce: Nonce!): ByteArray!

key

Key

nonce

Nonce

)

static fun encrypt(message: ByteArray!, key: Key!, nonce: Nonce!): ByteArray!

data

key

Key

nonce

Nonce

)

static fun encrypt(message: ByteArray!, data: ByteArray!, key: Key!, nonce: Nonce!): ByteArray!

nonce

Nonce

)

fun encryptDetached(message: ByteArray!, nonce: Nonce!):

data

nonce

Nonce

)

fun encryptDetached(message: ByteArray!, data: ByteArray!, nonce: Nonce!):

key

Key

nonce

Nonce

)

static fun encryptDetached(message: ByteArray!, key: Key!, nonce: Nonce!):

data

key

Key

nonce

Nonce

)

static fun encryptDetached(message: ByteArray!, data: ByteArray!, key: Key!, nonce: Nonce!):

static fun forKey(key: Key!):

AES256GCM

Module Contents

)

Key

Module Contents

)

Nonce

class Allocated : Destroyable

Module Contents

)

interface AsyncCompletion

class AppOptions

Module Contents

AppOptions()

var configPath: Path?

var help: Boolean

var web: String?

Module Contents

abstract fun accept(consumer: Consumer<in Throwable!>!):

open static fun allOf(vararg cs:

)

open static fun allOf(cs: MutableCollection<

)

open static fun allOf(cs: Stream<

)

open static fun completed():

static val COMPLETED:

open static fun exceptional(ex: Throwable!):

abstract fun exceptionally(consumer: Consumer<in Throwable!>!):

open static fun executeBlocking(action: Runnable!):

open static fun executeBlocking(executor: Executor!, action: Runnable!):

open static fun executeBlocking(vertx: Vertx!, action: Runnable!):

open static fun executeBlocking(executor: WorkerExecutor!, action: Runnable!):

abstract fun handle(fn: Function<in Throwable!, out U>!):

open static fun incomplete():

abstract fun join(): Unit

abstract fun join(timeout: Long, unit: TimeUnit!): Unit

open static fun runOnContext(vertx: Vertx!, fn: Supplier<out

)

open static fun runOnContext(vertx: Vertx!, action: Runnable!):

abstract fun then(fn: Supplier<out

)

abstract fun thenApply(other:

out

Function

out

)

)

abstract fun thenCompose(fn: Supplier<out

)

abstract fun thenConsume(other:

out

consumer

Consumer

)

abstract fun thenSchedule(vertx: Vertx!, fn: Supplier<out

)

abstract fun thenScheduleBlockingRun(vertx: Vertx!, runnable: Runnable!):

abstract fun thenScheduleBlockingRun(executor: WorkerExecutor!, runnable: Runnable!):

abstract fun thenScheduleRun(vertx: Vertx!, runnable: Runnable!):

abstract fun thenSupply(supplier: Supplier<out U>!):

abstract fun thenSupply(vertx: Vertx!, supplier: Supplier<out U>!):

abstract fun toFuture(): Future<Void!>!

abstract fun whenComplete(consumer: Consumer<in Throwable!>!):

abstract class AsyncMerkleStorage :

open suspend fun get(hash:

Module Contents

AsyncMerkleStorage()

)

abstract fun getAsync(hash:

)

open suspend fun put(hash:

content

abstract fun putAsync(hash:

)

Unit

content

)

interface AsyncResult<T : Any!>

Module Contents

abstract fun accept(consumer: BiConsumer<in T, Throwable!>!):

open static fun allOf(vararg rs:

)

open static fun allOf(rs: MutableCollection<out

)

open static fun allOf(rs: Stream<out

)

open static fun <T : Any!> combine(rs: MutableCollection<out

out

)

open static fun <T : Any!> combine(rs: Stream<out

MutableList

out

)

open static fun <T : Any!> completed(@Nullable value: T?):

MutableList

open static fun <T : Any!> exceptional(ex: Throwable!):

abstract fun exceptionally(fn: Function<Throwable!, out T>!):

open static fun <T : Any!> executeBlocking(fn: Supplier<T>!):

open static fun <T : Any!> executeBlocking(executor: Executor!, fn: Supplier<T>!):

open static fun <T : Any!> executeBlocking(vertx: Vertx!, fn: Supplier<T>!):

open static fun <T : Any!> executeBlocking(executor: WorkerExecutor!, fn: Supplier<T>!):

@Nullable abstract fun get(): T?

@Nullable abstract fun get(timeout: Long, unit: TimeUnit!): T?

abstract fun handle(fn: BiFunction<in T, Throwable!, out U>!):

open static fun <T : Any!> incomplete():

open static fun <T : Any!> runOnContext(vertx: Vertx!, fn: Supplier<out

)

abstract fun then(fn: Function<in T, out

)

abstract fun thenAccept(consumer: Consumer<in T>!):

abstract fun thenAcceptBoth(other:

out

consumer

BiConsumer

)

abstract fun thenApply(fn: Function<in T, out U>!):

out

BiFunction

out

)

abstract fun thenCompose(fn: Function<in T, out

)

abstract fun thenSchedule(vertx: Vertx!, fn: Function<in T, out

)

abstract fun thenScheduleApply(vertx: Vertx!, fn: Function<in T, out U>!):

abstract fun thenScheduleBlockingApply(vertx: Vertx!, fn: Function<in T, out U>!):

abstract fun thenScheduleBlockingApply(executor: WorkerExecutor!, fn: Function<in T, out U>!):

abstract fun thenScheduleBlockingRun(vertx: Vertx!, runnable: Runnable!):

abstract fun thenScheduleBlockingRun(executor: WorkerExecutor!, runnable: Runnable!):

abstract fun thenScheduleRun(vertx: Vertx!, runnable: Runnable!):

abstract fun whenComplete(action: BiConsumer<in T, in Throwable!>!):

class Auth

Module Contents

static fun auth(input:

key

Key

)

static fun auth(input: ByteArray!, key: Key!): ByteArray!

Module Contents

)

Key

static fun verify(tag:

input

static fun verify(tag: ByteArray!, input: ByteArray!, key: Key!): Boolean

key

Key

)

Boolean

open class Author

Module Contents

Author(id: String!)

static fun decode(b32: String!):

class Base32

Module Contents

static fun decodeBytes(b32: String!): ByteArray!

)

String

static fun decode(b58: String!):

class Base58

Module Contents

static fun decodeBytes(b58: String!): ByteArray!

)

String

class Base64

Module Contents

)

String

class Base64URLSafe

Module Contents

)

String

abstract class BaseUInt256Value<T :

protected BaseUInt256Value(value:

Module Contents

ctor

Function

protected BaseUInt256Value(value: Long, ctor: Function<

)

protected BaseUInt256Value(value: BigInteger!, ctor: Function<

)

)

)

)

modulus

)

)

)

Int

)

open fun divideCeil(value: T): T

open fun divideCeil(value:

open fun divideCeil(value: Long): T

)

)

open fun mod0(modulus:

open fun mod0(modulus: Long): T

)

)

)

modulus

)

open fun multiplyMod(value: Long, modulus: Long): T

)

)

)

open fun toUInt256():

abstract class BaseUInt32Value<T :

protected BaseUInt32Value(value:

Module Contents

ctor

Function

protected BaseUInt32Value(value: Int, ctor: Function<

)

protected BaseUInt32Value(value: BigInteger!, ctor: Function<

)

)

open fun add(value: Int): T

)

)

modulus

)

)

)

Int

open fun divide(value: Int): T

)

open fun mod(modulus: Int): T

)

open fun multiply(value: Int): T

)

)

modulus

open fun multiplyMod(value: Int, modulus:

)

open fun multiplyMod(value: Int, modulus: Int): T

)

)

open fun subtract(value: Int): T

)

open fun toUInt32():

abstract class BaseUInt384Value<T :

protected BaseUInt384Value(value:

Module Contents

ctor

Function

protected BaseUInt384Value(value: Long, ctor: Function<

)

protected BaseUInt384Value(value: BigInteger!, ctor: Function<

)

)

)

)

modulus

)

)

)

Int

)

)

)

)

modulus

)

open fun multiplyMod(value: Long, modulus: Long): T

)

)

)

open fun toUInt384():

abstract class BaseUInt64Value<T :

protected BaseUInt64Value(value:

Module Contents

ctor

Function

protected BaseUInt64Value(value: Long, ctor: Function<

)

protected BaseUInt64Value(value: BigInteger!, ctor: Function<

)

)

)

)

modulus

)

)

)

Int

)

)

)

)

modulus

)

open fun multiplyMod(value: Long, modulus: Long): T

)

)

)

open fun toUInt64():

Module Contents

body

)

)

)

BlockBody(transactions: MutableList<

)

Unit

class BlockBody

Module Contents

ommers

MutableList

)

)

fun getOmmers(): MutableList<

)

)

Unit

class BlockchainIndex :

BlockchainIndex(indexWriter: IndexWriter)

BlockchainIndexReader

Module Contents

fun chainHeadTotalDifficulty():

value

)

List

value

Long

)

List

value

)

List

value

)

List

value

)

List

value

)

List

value

)

List

value

Int

)

List

value

Long

)

List

value

)

List

value

)

List

value

)

List

value

)

List

fun findByBlockHashAndIndex(blockHash:

index

Int

)

fun findByHashOrNumber(hashOrNumber:

)

List

)

)

minValue

maxValue

)

List

minValue

maxValue

)

List

fun index(indexer: (

fun indexBlockHeader(blockHeader:

)

Unit

)

Unit

fun indexTransaction(transaction:

)

Unit

fun indexTransactionReceipt(txReceipt:

)

Unit

txIndex

Int

txHash

blockHash

fun totalDifficulty(hash:

)

Unit

)

interface BlockchainIndexReader

Module Contents

abstract fun chainHeadTotalDifficulty():

value

)

List

value

Long

)

List

value

)

List

value

)

List

value

)

List

value

)

List

value

)

List

value

Int

)

List

value

Long

)

List

value

)

List

value

)

List

value

)

List

value

)

List

abstract fun findByBlockHashAndIndex(blockHash:

index

Int

)

abstract fun findByHashOrNumber(hashOrNumber:

)

List

)

)

minValue

maxValue

)

List

minValue

maxValue

)

List

abstract fun totalDifficulty(hash:

)

interface BlockchainIndexWriter

Module Contents

abstract fun indexBlockHeader(blockHeader:

abstract fun indexTransaction(transaction:

)

Unit

abstract fun indexTransactionReceipt(txReceipt:

)

Unit

txIndex

Int

txHash

blockHash

interface BlockchainInformation

)

Unit

Module Contents

abstract fun bestHash():

abstract fun bestNumber():

abstract fun forks(): List<Long>

abstract fun genesisHash():

open fun getForkHashes(): List<

open fun getLatestFork(): Long?

open fun getLatestForkHash():

abstract fun networkID():

abstract fun totalDifficulty():

class BlockchainRepository

Module Contents

BlockchainRepository(chainMetadata:

blockBodyStore

blockHeaderStore

transactionReceiptStore

transactionStore

stateStore

blockchainIndex

)

suspend fun accountsExists(address:

)

Boolean

fun findBlockByHashOrNumber(blockNumberOrBlockHash:

)

List

fun findBlocksByParentHash(parentHash:

)

List

suspend fun getAccount(address:

)

suspend fun getAccountCode(address:

)

suspend fun getAccountStoreValue(address:

key

)

suspend fun hasBlockBody(blockHash:

suspend fun hasBlockHeader(blockHash:

)

Boolean

suspend fun init(blockBodyStore:

)

Boolean

blockHeaderStore

chainMetadata

transactionReceiptsStore

transactionStore

stateStore

blockchainIndex

genesisBlock

)

suspend fun retrieveBlock(blockHash:

)

suspend fun retrieveBlockBody(blockHash:

)

suspend fun retrieveBlockBodyBytes(blockHash:

)

suspend fun retrieveBlockHeader(blockHash:

)

suspend fun retrieveBlockHeaderBytes(blockHash:

)

suspend fun retrieveChainHead():

suspend fun retrieveChainHeadHeader():

suspend fun retrieveGenesisBlock():

suspend fun retrieveNodeData(hashes: List<

)

List

suspend fun retrieveTransactionReceipt(blockHash:

index

Int

)

suspend fun retrieveTransactionReceipt(txHash:

)

suspend fun retrieveTransactionReceipts(blockHash:

)

List

suspend fun storeAccount(address:

account

suspend fun storeBlock(block:

)

Unit

suspend fun storeBlockBody(blockHash:

)

Unit

blockBody

suspend fun storeBlockHeader(:

)

Unit

suspend fun storeCode(code:

)

Unit

suspend fun storeNodeData(hash:

)

Unit

bytes

suspend fun storeTransaction(transaction:

)

Unit

suspend fun storeTransactionReceipt(transactionReceipt:

)

Unit

txIndex

Int

txHash

blockHash

BlockHeader(@Nullable parentHash:

)

Unit

class BlockHeader

Module Contents

ommersHash

coinbase

stateRoot

transactionsRoot

receiptsRoot

logsBloom

difficulty

number

gasLimit

gasUsed

timestamp

Instant

extraData

mixHash

nonce

)

@Nullable fun getParentHash():

)

fun getReceiptsRoot():

fun getTimestamp(): Instant!

fun getTransactionsRoot():

)

enum class BlockHeaderFields

Module Contents

COINBASE

DIFFICULTY

EXTRA_DATA

Module Contents

BlockStats(blockNumber:

hash

parentHash

timestamp

Long

miner

gasUsed

Long

gasLimit

Long

difficulty

totalDifficulty

transactions

MutableList

transactionsRoot

stateRoot

uncles

MutableList

fun getBlockNumber(): Long

)

fun getDifficulty(): String!

fun getGasLimit(): Long

fun getGasUsed(): Long

fun getHash(): String!

fun getTimestamp(): Long

fun getTotalDifficulty(): String!

fun getTransactionsRoot(): String!

fun getUncles(): MutableList<

class BLS12381

Module Contents

message

ByteArray

domain

Int

)

message

domain

Int

)

signature

message

ByteArray

domain

Int

)

Boolean

signature

message

domain

Int

)

Boolean

message

ByteArray

domain

Int

)

Boolean

message

open class BouncyCastleExtension : BeforeAllCallback

domain

Int

)

Boolean

Module Contents

BouncyCastleExtension()

open fun beforeAll(context: ExtensionContext!): Unit

class Box : AutoCloseable

Module Contents

nonce

Nonce

)

@Nullable fun decrypt(cipherText: ByteArray!, nonce: Nonce!): ByteArray?

sender

PublicKey

receiver

SecretKey

nonce

Nonce

)

@Nullable static fun decrypt(cipherText: ByteArray!, sender: PublicKey!, receiver: SecretKey!, nonce: Nonce!): ByteArray?

mac

nonce

Nonce

)

@Nullable fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, nonce: Nonce!): ByteArray?

mac

sender

PublicKey

receiver

SecretKey

nonce

Nonce

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, sender: PublicKey!, receiver: SecretKey!, nonce: Nonce!): ByteArray?

@Nullable static fun decryptSealed(cipherText:

sender

PublicKey

receiver

SecretKey

)

@Nullable static fun decryptSealed(cipherText: ByteArray!, sender: PublicKey!, receiver: SecretKey!): ByteArray?

nonce

Nonce

)

fun encrypt(message: ByteArray!, nonce: Nonce!): ByteArray!

receiver

PublicKey

sender

SecretKey

nonce

Nonce

)

static fun encrypt(message: ByteArray!, receiver: PublicKey!, sender: SecretKey!, nonce: Nonce!): ByteArray!

nonce

Nonce

)

fun encryptDetached(message: ByteArray!, nonce: Nonce!):

receiver

PublicKey

sender

SecretKey

nonce

Nonce

)

static fun encryptDetached(message: ByteArray!, receiver: PublicKey!, sender: SecretKey!, nonce: Nonce!):

static fun encryptSealed(message:

receiver

PublicKey

)

static fun encryptSealed(message: ByteArray!, receiver: PublicKey!): ByteArray!

static fun forKeys(receiver: PublicKey!, sender: SecretKey!):

Box

KeyPair(publicKey: PublicKey!, secretKey: SecretKey!)

Module Contents

static fun forSecretKey(secretKey: SecretKey!): KeyPair!

static fun forSignatureKeyPair(keyPair: KeyPair!): KeyPair!

Module Contents

)

Nonce

Module Contents

static fun forSignaturePublicKey(publicKey: PublicKey!): PublicKey!

static fun fromBytes(bytes: ByteArray!): PublicKey!

)

PublicKey

Module Contents

static fun forSignatureSecretKey(secretKey: SecretKey!): SecretKey!

static fun fromBytes(bytes: ByteArray!): SecretKey!

)

SecretKey

Module Contents

)

Seed

interface Bytes : Comparable<

Module Contents

)

and

(

other

open fun <T : Appendable!> appendHexTo(appendable: T): T

result

)

open fun appendTo(byteBuffer: ByteBuffer!): Unit

open fun appendTo(buffer: Buffer!): Unit

open fun commonPrefix(other:

)

open fun commonPrefixLength(other:

)

Int

open static fun concatenate(values: MutableList<

)

Int

)

open static fun concatenate(vararg values:

)

)

Unit

destinationOffset

Int

)

Unit

open static fun fromBase64String(str: CharSequence!):

open static fun fromHexString(str: CharSequence!, destinationSize: Int):

open static fun fromHexStringLenient(str: CharSequence!):

open static fun fromHexStringLenient(str: CharSequence!, destinationSize: Int):

abstract fun get(i: Int): Byte

open fun getInt(i: Int): Int

open fun getInt(i: Int, order: ByteOrder!): Int

open fun getLong(i: Int): Long

open fun getLong(i: Int, order: ByteOrder!): Long

open fun hasLeadingZero(): Boolean

open fun hasLeadingZeroByte(): Boolean

open fun isEmpty(): Boolean

open static fun minimalBytes(value: Long):

open fun numberOfLeadingZeroBytes(): Int

not

(

result

)

open fun numberOfTrailingZeroBytes(): Int

open static fun ofUnsignedInt(value: Long):

open static fun ofUnsignedInt(value: Long, order: ByteOrder!):

open static fun ofUnsignedLong(value: Long):

open static fun ofUnsignedLong(value: Long, order: ByteOrder!):

open static fun ofUnsignedShort(value: Int):

open static fun ofUnsignedShort(value: Int, order: ByteOrder!):

)

(

other

open static fun random(size: Int):

result

)

open static fun random(size: Int, generator: Random!):

open fun reverse():

shiftLeft

(

distance

Int

result

)

shiftRight

(

distance

Int

result

)

open fun slice(i: Int):

abstract fun slice(i: Int, length: Int):

open fun toArray(): ByteArray!

open fun toArray(byteOrder: ByteOrder!): ByteArray!

open fun toArrayUnsafe(): ByteArray!

open fun toBase64String(): String!

open fun toBigInteger(order: ByteOrder!): BigInteger!

open fun toEllipsisHexString(): String!

open fun toInt(order: ByteOrder!): Int

open fun toInt(): Int

open fun toLong(order: ByteOrder!): Long

open fun toQuantityHexString(): String!

open fun toUnprefixedHexString(): String!

open fun toUnsignedBigInteger(): BigInteger!

open fun toUnsignedBigInteger(order: ByteOrder!): BigInteger!

open fun trimLeadingZeros():

open fun update(digest: MessageDigest!): Unit

open static fun wrap(value: ByteArray!, offset: Int, length: Int):

open static fun wrap(vararg values:

)

open static fun wrapBuffer(buffer: Buffer!, offset: Int, size: Int):

open static fun wrapByteBuf(byteBuf: ByteBuf!, offset: Int, size: Int):

open static fun wrapByteBuffer(byteBuffer: ByteBuffer!):

open static fun wrapByteBuffer(byteBuffer: ByteBuffer!, offset: Int, size: Int):

)

xor

(

other

result

)

Module Contents

)

open static fun fromHexStringLenient(str: CharSequence!):

open static fun fromHexStringStrict(str: CharSequence!):

)

)

)

open static fun wrap(bytes: ByteArray!, offset: Int):

)

offset

Int

)

)

Module Contents

)

open static fun fromHexStringLenient(str: CharSequence!):

open static fun fromHexStringStrict(str: CharSequence!):

)

)

)

open static fun wrap(bytes: ByteArray!, offset: Int):

)

offset

Int

)

)

Module Contents

interface ClientHandler

Module Contents

)

Unit

interface ClientHandlerFactory<T :

Module Contents

class ClientRequestException : RuntimeException

terminationFunction

Runnable

)

Module Contents

ClientRequestException(message: String)

class CompactEncoding

Module Contents

static fun bytesToPath(bytes:

)

static fun decode(encoded:

)

static fun encode(path:

)

static val LEAF_TERMINATOR: Byte

interface CompletableAsyncCompletion :

abstract fun complete(): Boolean

Module Contents

abstract fun completeExceptionally(ex: Throwable!): Boolean

abstract fun toFuture(): CompletableFuture<Void!>!

interface CompletableAsyncResult<T : Any!> :

abstract fun complete(@Nullable value: T?): Boolean

Module Contents

abstract fun completeExceptionally(ex: Throwable!): Boolean

class Concatenate

Module Contents

Concatenate()

)

fun add(key: Secret!):

fun concatenate():

open static fun canonicalKey(key: String!): String!

interface Configuration

Module Contents

abstract fun contains(key: String!): Boolean

open static fun empty():

open static fun empty(@Nullable schema:

)

open static fun fromToml(toml: String!):

open static fun fromToml(toml: String!, @Nullable schema:

)

open static fun fromToml(file: Path!):

open static fun fromToml(file: Path!, @Nullable schema:

)

open static fun fromToml(is: InputStream!):

open static fun fromToml(is: InputStream!, @Nullable schema:

)

@Nullable abstract fun get(key: String!): Any?

abstract fun getBoolean(key: String!): Boolean

abstract fun getConfigurationSection(name: String!):

abstract fun getDouble(key: String!): Double

abstract fun getInteger(key: String!): Int

abstract fun getList(key: String!): MutableList<Any!>!

abstract fun getListOfBoolean(key: String!): MutableList<Boolean!>!

abstract fun getListOfDouble(key: String!): MutableList<Double!>!

abstract fun getListOfInteger(key: String!): MutableList<Int!>!

abstract fun getListOfLong(key: String!): MutableList<Long!>!

abstract fun getListOfMap(key: String!): MutableList<MutableMap<String!, Any!>!>!

abstract fun getListOfString(key: String!): MutableList<String!>!

abstract fun getLong(key: String!): Long

abstract fun getMap(key: String!): MutableMap<String!, Any!>!

abstract fun getString(key: String!): String!

@Nullable abstract fun inputPositionOf(key: String!):

abstract fun keySet(prefix: String!): MutableSet<String!>!

abstract fun sections(prefix: String!): MutableSet<String!>!

open fun toToml(): String!

open fun toToml(path: Path!): Unit

abstract fun toToml(appendable: Appendable!): Unit

class ConfigurationError : RuntimeException

Module Contents

ConfigurationError(message: String!)

ConfigurationError(message: String!, @Nullable cause: Throwable?)

message

String

)

message

String

@Nullable

cause

Throwable

)

class ConfigurationErrors

Module Contents

static fun noErrors(): MutableList<

static fun singleError(message: String!): MutableList<

static fun singleError(message: String!, @Nullable cause: Throwable?): MutableList<

message

String

)

MutableList

message

String

@Nullable

cause

Throwable

)

MutableList

@Path("config") class ConfigurationService

Module Contents

ConfigurationService()

var context: ServletContext?

@GET @Produces(["text/plain"]) fun get(): String

interface ConfigurationValidator

Module Contents

abstract fun validate(configuration:

)

MutableList

abstract fun active(): Boolean

interface Connection

Module Contents

abstract fun identity():

abstract fun peer():

open class ConnectionClosedException : Exception

Module Contents

ConnectionClosedException()

open class CouldNotSerializeException : RuntimeException

Module Contents

CouldNotSerializeException(ex: IOException!)

interface DataStoreConfiguration

Module Contents

abstract fun getGenesisFile(): String

abstract fun getStoragePath(): Path

class DefaultWireConnection :

DefaultWireConnection(nodeId:

Module Contents

peerNodeId

writer

Consumer

afterHandshakeListener

Consumer

disconnectHandler

Runnable

subprotocols

LinkedHashMap

p2pVersion

Int

clientId

String

advertisedPort

Int

ready

fun agreedSubprotocols(): MutableCollection<

peerHost

String

peerPort

Int

)

fun disconnect(reason:

fun getDisconnectReason():

)

Unit

fun getPeerHello():

fun handleConnectionStart(): Unit

fun isDisconnectReceived(): Boolean

fun isDisconnectRequested(): Boolean

fun messageReceived(message:

)

Unit

fun peerHost(): String!

fun peerPort(): Int

fun registerListener(listener: EventListener!): Unit

fun sendMessage(subProtocolIdentifier:

messageType

Int

message

)

Unit

fun sendPing():

)

Boolean

open class DelegatingBytes :

protected DelegatingBytes(delegate:

Module Contents

)

open class DelegatingBytes32 :

protected DelegatingBytes32(delegate:

Module Contents

)

open class DelegatingBytes48 :

protected DelegatingBytes48(delegate:

Module Contents

)

interface DetachedEncryptionResult

Module Contents

abstract fun cipherText():

abstract fun cipherTextArray(): ByteArray!

abstract fun mac():

abstract fun macArray(): ByteArray!

class DiffieHelman

Module Contents

DiffieHelman()

KeyPair(publicKey: PublicKey!, secretKey: SecretKey!)

Module Contents

static fun forSecretKey(secretKey: SecretKey!): KeyPair!

Module Contents

static fun forBoxPublicKey(publicKey: PublicKey!): PublicKey!

static fun forSignaturePublicKey(publicKey: PublicKey!): PublicKey!

static fun fromBytes(bytes: ByteArray!): PublicKey!

)

PublicKey

class Secret : Destroyable

Module Contents

static fun forKeys(secretKey: SecretKey!, publicKey: PublicKey!): Secret!

static fun fromBytes(bytes: ByteArray!): Secret!

)

Secret

Module Contents

static fun forBoxSecretKey(secretKey: SecretKey!): SecretKey!

static fun forSignatureSecretKey(secretKey: SecretKey!): SecretKey!

static fun fromBytes(bytes: ByteArray!): SecretKey!

)

SecretKey

INCOMPATIBLE_DEVP2P_VERSION

class DisconnectReason

Module Contents

NULL_NODE_IDENTITY_RECEIVED

static fun valueOf(reason: Int):

class DiscoveryPeerRepository :

DiscoveryPeerRepository(repository:

Module Contents

suspend fun get(host: String, port: Int, nodeId: PublicKey):

)

interface DiscoveryService

Module Contents

abstract suspend fun awaitBootstrap(): Unit

abstract fun awaitBootstrapAsync():

abstract val expiredPackets: Long

abstract val filteredPackets: Long

abstract val invalidPackets: Long

abstract val isShutdown: Boolean

abstract val localPort: Int

abstract suspend fun lookup(target: PublicKey): List<

abstract fun lookupAsync(target: PublicKey):

List

@JvmOverloads fun open(vertx: Vertx, keyPair: KeyPair, port: Int = 0, host: String? = null, seq: Long = Instant.now().toEpochMilli(), enrData: Map<String,

bootstrapURIs

List

URI

peerRepository

advertiseAddress

String

advertiseUdpPort

Int

advertiseTcpPort

Int

routingTable

packetFilter

(

PublicKey

SocketAddress

)

Boolean

)

timeSupplier

(

)

Long

)

@JvmOverloads fun open(vertx: Vertx, keyPair: KeyPair, bindAddress: SocketAddress, seq: Long = Instant.now().toEpochMilli(), enrData: Map<String,

bootstrapURIs

List

URI

peerRepository

advertiseAddress

String

advertiseUdpPort

Int

advertiseTcpPort

Int

routingTable

packetFilter

(

PublicKey

SocketAddress

)

Boolean

)

timeSupplier

(

)

Long

)

abstract val selfPackets: Long

abstract suspend fun shutdown(): Unit

abstract fun shutdownAsync():

abstract val unexpectedENRResponses: Long

abstract val unexpectedNeighbors: Long

abstract val unexpectedPongs: Long

abstract val unvalidatedPeerPackets: Long

object DiscoveryService

Module Contents

@JvmStatic @JvmOverloads fun open(vertx: Vertx, keyPair: KeyPair, localPort: Int, bindAddress: InetSocketAddress = InetSocketAddress(InetAddress.getLoopbackAddress(), localPort), enrSeq: Long = Instant.now().toEpochMilli(), bootstrapENRList: List<String> = emptyList(), enrStorage:

ENRStorage

coroutineContext

CoroutineContext

)

DiscoveryV5Service

interface DiscoveryV5Service : CoroutineScope

Module Contents

open suspend fun addPeer(rlpENR:

)

abstract suspend fun addPeer(enr:

address

SocketAddress

)

abstract fun enr():

abstract suspend fun requestNodes(distance: Int = 1, maxSecondsToWait: Long = 10):

Map

List

abstract suspend fun start():

open fun startAsync():

abstract suspend fun terminate(): Unit

open fun terminateAsync():

Module Contents

metadataStore

String

peerRepository

suspend fun seq(seq: Long): Unit

)

suspend fun seq(): Long

interface DNSConfiguration

Module Contents

abstract fun domain(): String

abstract fun pollingPeriod(): Long

data class DNSConfigurationImpl :

DNSConfigurationImpl(name: String, peerRepository: String, domain: String, pollingPeriod: Long)

Module Contents

fun domain(): String

fun getName(): String

fun peerRepository(): String

fun pollingPeriod(): Long

class DNSDaemon

Module Contents

DNSDaemon(enrLink: String, listener:

seq

Long

period

Long

dnsServer

String

resolver

Resolver

)

val listeners: HashSet<

@FunctionalInterface interface DNSDaemonListener

Module Contents

abstract fun newRecords(seq: Long, records: List<

fun readDNSEntry(serialized: String):

)

Unit

interface DNSEntry

Module Contents

DNSResolver(dnsServer: String? = null, seq: Long = 0, resolver: Resolver = SimpleResolver(dnsServer))

class DNSResolver

Module Contents

fun collectAll(enrLink: String): List<

fun resolveRecord(domainName: String):

fun resolveRecordRaw(domainName: String): String?

var seq: Long

fun visitTree(enrLink: String, visitor:

DNSVisitor

)

Unit

interface DNSVisitor

Module Contents

abstract fun visit(enr:

)

Boolean

class DocumentPosition

Module Contents

open class EndOfRLPException :

open class EndOfSSZException :

Module Contents

EndOfRLPException()

Endpoint(address: SocketAddress, tcpPort: Int? = null)

Module Contents

EndOfSSZException()

data class Endpoint

Module Contents

Endpoint(address: String, udpPort: Int = DEFAULT_PORT, tcpPort: Int? = null)

val address: String

const val DEFAULT_PORT: Int

)

val tcpSocketAddress: InetSocketAddress?

val udpPort: Int

val udpSocketAddress: SocketAddress

data class EnodeUriComponents

Module Contents

EnodeUriComponents(nodeId: PublicKey, endpoint:

)

val endpoint:

abstract fun find(nodeId:

val nodeId: PublicKey

interface ENRStorage

Module Contents

)

abstract fun put(nodeId:

enr

)

Unit

open fun set(enr:

class EntityManagerKeyValueStore<K, V> :

)

Unit

EntityManagerKeyValueStore(entityManagerProvider: () -> EntityManager, entityClass: Class<V>, idAccessor: (V) -> K, coroutineContext: CoroutineContext = Dispatchers.IO)

Module Contents

@JvmStatic fun <K, V> open(entityManagerProvider: Supplier<EntityManager>, entityClass: Class<V>, idAccessor: Function<V, K>):

EntityManagerKeyValueStore

suspend fun put(value: V): Unit

Module Contents

fun get(nodeId: PublicKey, endpoint:

)

suspend fun get(host: String, port: Int, nodeId: PublicKey):

Module Contents

fun addEager(peer:

fun considerNewPeer(peer:

)

Unit

fun eagerPushPeers(): MutableCollection<

)

Unit

fun lazyPushPeers(): MutableCollection<

fun moveToEager(peer:

)

Unit

fun moveToLazy(peer:

fun peers(): MutableList<

)

Boolean

)

Unit

Module Contents

pendingTransactionsPool

fun nodeDataWasRequested(connection:

)

elements

List

)

fun requestBlock(blockHash:

)

fun requestBlockBodies(blockHashes: List<

)

)

fun requestBlockHeaders(blockHash:

maxHeaders

Long

skip

Long

reverse

Boolean

)

fun requestBlockHeaders(blockNumber: Long, maxHeaders: Long, skip: Long, reverse: Boolean):

fun requestBlockHeaders(blockHashes: List<

)

fun requestTransactionReceipts(blockHashes: List<

)

suspend fun submitPooledTransaction(vararg tx:

fun transactionReceiptsRequested(connection:

)

Unit

transactionReceipts

List

)

)

bodies

List

)

EthController(repository:

class EthController

Module Contents

pendingTransactionsPool

requestsManager

connectionsListener

(

suspend fun addNewBlock(newBlock:

)

Unit

)

suspend fun addNewBlockBodies(connection:

)

Unit

bodies

List

suspend fun addNewBlockHashes(hashes: List<Pair<

)

Unit

suspend fun addNewBlockHeaders(connection:

Long

)

Unit

headers

List

suspend fun addNewNodeData(connection:

)

Unit

elements

List

suspend fun addNewPooledTransactions(transactions: List<

)

Unit

suspend fun addNewTransactionReceipts(connection:

)

Unit

transactionReceipts

List

suspend fun addNewTransactions(transactions: List<

)

Unit

val connectionsListener: (

)

Unit

suspend fun findBlockBodies(hashes: List<

)

Unit

)

List

suspend fun findHeaders(block:

maxHeaders

Long

skip

Long

reverse

Boolean

)

List

suspend fun findNodeData(hashes: List<

)

List

suspend fun findPooledTransactions(hashes: List<

)

List

suspend fun findTransactionReceipts(hashes: List<

)

List

val pendingTransactionsPool:

fun receiveStatus(connection:

status

)

Unit

)

Unit

val requestsManager:

class EthereumClient : CoroutineScope

Module Contents

EthereumClient(vertx: Vertx, config:

coroutineContext

CoroutineContext

)

val config:

class EthereumClientConfig

Module Contents

EthereumClientConfig(config:

)

fun createSchema():

fun dataStores(): List<

DataStoreConfiguration

fun dnsClients(): List<

fun empty():

fun fromFile(path: Path?):

fun fromString(config: String):

fun genesisFiles(): List<

GenesisFileConfiguration

fun peerRepositories(): List<

PeerRepositoryConfiguration

fun rlpxServices(): List<

RLPxServiceConfiguration

fun toToml(): String!

open class EthereumIESEncryptionEngine

Module Contents

EthereumIESEncryptionEngine(agree: BasicAgreement!, kdf: DerivationFunction!, mac: Mac!, commonMac: ByteArray!, cipher: BufferedBlockCipher!)

protected open fun getLengthTag(p2: ByteArray!): ByteArray!

open fun init(forEncryption: Boolean, privParam: CipherParameters!, pubParam: CipherParameters!, params: CipherParameters!): Unit

open fun processBlock(in: ByteArray!, inOff: Int, inLen: Int): ByteArray!

class EthereumNodeRecord

Module Contents

EthereumNodeRecord(signature:

seq

Long

data

Map

String

listData

Map

String

List

rlp

@JvmOverloads @JvmStatic fun create(signatureKeyPair: KeyPair, seq: Long = Instant.now().toEpochMilli(), data: Map<String,

)

listData

Map

String

List

InetAddress

tcp

Int

udp

Int

)

val data: Map<String,

fun encode(signatureKeyPair: KeyPair? = null, seq: Long = Instant.now().toEpochMilli(), ip: InetAddress? = null, tcp: Int? = null, udp: Int? = null, data: Map<String,

listData

Map

String

List

writer

)

Unit

@JvmStatic fun fromRLP(rlp:

)

)

val listData: Map<String, List<

rlp

)

fun ip(): InetAddress

fun nodeId(publicKey: PublicKey):

fun publicKey(): PublicKey

fun publicKeyBytes():

@JvmOverloads @JvmStatic fun toRLP(signatureKeyPair: KeyPair, seq: Long = Instant.now().toEpochMilli(), data: Map<String,

listData

Map

String

List

InetAddress

tcp

Int

udp

Int

)

class EthereumVirtualMachine

fun udp(): Int?

fun validate(): Unit

Module Contents

EthereumVirtualMachine(repository:

evmcFile

String

vmFile

String

options

Map

String

)

fun capabilities(): Int

destination

value

code

inputData

gas

gasPrice

currentCoinbase

currentNumber

Long

currentTimestamp

Long

currentGasLimit

Long

currentDifficulty

callKind

CallKind

revision

HardFork

depth

Int

)

static var CACHE_BYTES_GROWTH: Long

fun version(): String

open class EthHash

Module Contents

EthHash()

static var ACCESSES: Int

static var CACHE_BYTES_INIT: Long

static var CACHE_MULTIPLIER: Int

static var CACHE_ROUNDS: Int

open static fun calcDatasetItem(cache: Array<

index

)

static var DATASET_BYTES_GROWTH: Long

static var DATASET_BYTES_INIT: Long

static var DATASET_PARENTS: Int

open static fun epoch(block: Long): Long

static var EPOCH_LENGTH: Int

static var FNV_PRIME: Int

open static fun getCacheSize(block_number: Long): Int

open static fun getFullSize(block_number: Long): Long

static var HASH_BYTES: Int

open static fun hashimotoLight(size: Long, cache: Array<

nonce

)

static var MIX_BYTES: Int

open static fun mkCache(cacheSize: Int, block: Long): Array<

static var WORD_BYTES: Int

open class EthJsonModule : SimpleModule

Module Contents

EthJsonModule()

interface EthRequestsManager

Module Contents

abstract fun nodeDataWasRequested(connection:

elements

List

)

abstract fun requestBlock(blockHash:

)

abstract fun requestBlockBodies(blockHashes: List<

)

abstract fun requestBlockHeader(blockHash:

)

abstract fun requestBlockHeaders(blockHashes: List<

)

abstract fun requestBlockHeaders(blockHash:

maxHeaders

Long

skip

Long

reverse

Boolean

)

abstract fun requestBlockHeaders(blockNumber: Long, maxHeaders: Long, skip: Long, reverse: Boolean):

abstract fun requestTransactionReceipts(blockHashes: List<

)

abstract suspend fun submitPooledTransaction(vararg tx:

abstract fun transactionReceiptsRequested(connection:

)

Unit

transactionReceipts

List

)

)

bodies

List

)

EthStatsReporter(vertx: Vertx!, id: String!, ethstatsServerURIs: MutableList<URI!>!, secret: String!, name: String!, node: String!, port: Int, network: String!, protocol: String!, os: String!, osVer: String!, historyRequester: Consumer<MutableList<

class EthStatsReporter

Module Contents

fun sendHistoryResponse(blocks: MutableList<

timeSupplier

Supplier

Long

)

fun sendNewHead(newBlockStats:

)

Unit

fun sendNewNodeStats(nodeStats:

)

Unit

NodeStats

)

Unit

fun sendNewPendingTransactionCount(txCount: Int): Unit

fun start():

class EthSubprotocol :

EthSubprotocol(coroutineContext: CoroutineContext = Dispatchers.Default, blockchainInfo:

Module Contents

repository

pendingTransactionsPool

listener

(

)

Unit

)

)

client

)

val ETH63:

val ETH64:

val ETH65:

fun getCapabilities(): MutableList<

fun id():

)

Boolean

enum class EVMExecutionStatusCode

Module Contents

EVMC_ARGUMENT_OUT_OF_RANGE

EVMC_BAD_JUMP_DESTINATION

EVMC_CALL_DEPTH_EXCEEDED

EVMC_CONTRACT_VALIDATION_FAILURE

EVMC_FAILURE

EVMC_INTERNAL_ERROR

EVMC_INVALID_INSTRUCTION

EVMC_INVALID_MEMORY_ACCESS

EVMC_OUT_OF_GAS

EVMC_OUT_OF_MEMORY

EVMC_PRECOMPILE_FAILURE

EVMC_STATIC_MODE_VIOLATION

EVMC_SUCCESS

EVMC_UNDEFINED_INSTRUCTION

EVMC_WASM_TRAP

EVMC_WASM_UNREACHABLE_INSTRUCTION

data class EVMResult

Module Contents

EVMResult(statusCode:

gasLeft

Long

hostContext

)

fun fromBytes(bytes:

hostContext

)

val gasLeft: Long

val hostContext:

val statusCode:

class ExpiringMap<K : Any!, V : Any!> : MutableMap<K, V>

Module Contents

ExpiringMap()

fun compute(key: K, remappingFunction: BiFunction<in K, in V?, out V?>): V?

fun computeIfAbsent(key: K, mappingFunction: Function<in K, out V>): V

fun computeIfPresent(key: K, remappingFunction: BiFunction<in K, in V, out V?>): V?

fun containsKey(key: K): Boolean

fun containsValue(value: V): Boolean

val entries: MutableSet<MutableEntry<K, V>>

fun forEach(action: BiConsumer<in K, in V>): Unit

@Nullable fun get(key: K): V?

fun getOrDefault(key: K, defaultValue: V): V

fun merge(key: K, value: V, remappingFunction: BiFunction<in V, in V, out V?>): V?

val keys: MutableSet<K>

@Nullable fun put(key: K, value: V): V?

@Nullable fun put(key: K, value: V, expiry: Long): V?

@Nullable fun put(key: K, value: V, expiry: Long, @Nullable expiryListener: BiConsumer<K, V>?): V?

fun putAll(from: Map<out K, V>): Unit

@Nullable fun putIfAbsent(key: K, value: V): V?

@Nullable fun putIfAbsent(key: K, value: V, expiry: Long): V?

@Nullable fun putIfAbsent(key: K, value: V, expiry: Long, @Nullable expiryListener: BiConsumer<K, V>?): V?

fun remove(key: K): V?

fun remove(key: K, value: V): Boolean

fun replace(key: K, value: V): V?

fun replace(key: K, oldValue: V, newValue: V): Boolean

fun replaceAll(function: BiFunction<in K, in V, out V>): Unit

val values: MutableCollection<V>

class ExpiringSet<E : Any!> : MutableSet<E>

Module Contents

ExpiringSet(evictionTimeout: Long)

ExpiringSet()

fun add(element: E): Boolean

fun add(element: E, expiry: Long): Boolean

fun add(element: E, expiry: Long, @Nullable expiryListener: Consumer<E>?): Boolean

fun addAll(elements: Collection<E>): Boolean

fun contains(element: E): Boolean

fun containsAll(elements: Collection<E>): Boolean

fun iterator(): MutableIterator<E>

fun remove(element: E): Boolean

fun removeAll(elements: Collection<E>): Boolean

fun retainAll(elements: Collection<E>): Boolean

fun toArray(): Array<Any!>!

fun <T : Any!> toArray(a: Array<T>!): Array<T>!

@SpringBootApplication class FaucetApplication

Module Contents

FaucetApplication()

var authorizedOrg: String?

var banner: String?

@PostConstruct fun banner(): Unit

@PreDestroy fun close(): Unit

@Bean fun createVertx(): Vertx

@Bean(["wallet"]) fun createWallet(@Value("${wallet.path}") path: String, @Value("${wallet.password}") password: String):

@Bean fun createWebClient(): WebClient

@Bean fun oauth2UserService(rest: WebClient): OAuth2UserService<OAuth2UserRequest, OAuth2User>?

val vertx: Vertx!

@Controller class FaucetController

Module Contents

FaucetController()

var chainId: Int?

@PostConstruct fun createClient(): Unit

var gas: Long?

var gasPrice: Long?

@GetMapping(["/"]) fun index(model: Model): String

@PostMapping(["/"]) fun send(@ModelAttribute request:

FaucetRequest

model

Model

)

String

Module Contents

FaucetRequest(addr: String?, message: String?)

var addr: String?

var message: String?

open class FeedMessage

Module Contents

FeedMessage(key: String!, type: Optional<String!>!, value:

)

open fun getType(): Optional<String!>!

open fun getValue():

open class FeedMessageDeserializer : JsonDeserializer<

FeedMessageDeserializer()

Module Contents

open fun deserialize(jp: JsonParser!, ctxt: DeserializationContext!):

fun createFeedStream(streamHandler: Function<Runnable!,

class FeedService

Module Contents

)

Unit

publish

(

content

)

FeedValue(previous: String!, author:

open class FeedValue

Module Contents

sequence

Long

timestamp

Long

hash

String

content

JsonNode

)

open fun getAuthor():

open fun <T : Any!> getContentAs(mapper: ObjectMapper!, clazz: Class<T>!): T

open fun getContentAsJsonString(): String!

open fun getHash(): String!

open fun getPrevious(): String!

open fun getSequence(): Long

open fun getTimestamp(): Long

class Files

Module Contents

static fun atomicReplace(path: Path!, bytes: ByteArray!): Unit

static fun atomicReplace(path: Path!, fn:

static fun atomicReplace(path: Path!, charset: Charset!, fn:

Writer

)

Unit

static fun copyResource(resourceName: String!, destination: Path!, vararg options: OpenOption!): Path!

Writer

)

Unit

static fun copyResource(classloader: ClassLoader!, resourceName: String!, destination: Path!, vararg options: OpenOption!): Path!

static fun copyResource(resourceName: String!, out: OutputStream!): Long

static fun copyResource(classloader: ClassLoader!, resourceName: String!, out: OutputStream!): Long

static fun createFileIfMissing(path: Path!, vararg attrs: FileAttribute<*>!): Boolean

static fun deleteRecursively(directory: Path!): Unit

interface FingerprintRepository

Module Contents

abstract fun addFingerprint(identifier: String!, fingerprint:

abstract fun contains(identifier: String!): Boolean

)

Unit

abstract fun contains(identifier: String!, fingerprint:

fun compareTo(other: Long): Int

)

Boolean

Module Contents

)

fun priceFor(gasPrice:

)

)

class GenericHash

Module Contents

GenericHash()

Module Contents

static fun hash(hashLength: Int, input: Input!): Hash!

static fun hash(hashLength: Int, input: Input!, key: Key!): Hash!

Module Contents

)

Input

)

Input

Module Contents

)

Key

)

Key

GenesisFile(nonce: String!, difficulty: String!, mixhash: String!, coinbase: String!, timestamp: String!, extraData: String!, gasLimit: String!, parentHash: String!, allocs: MutableMap<String!, String!>!, chainId: Int, forks: MutableList<Long!>!)

open class GenesisFile

Module Contents

open fun getAllocations(): MutableMap<

open fun getChainId(): Int

open fun getForks(): MutableList<Long!>!

open static fun read(contents: ByteArray!):

open fun toBlock():

interface GenesisFileConfiguration

Module Contents

abstract fun genesisFile():

static fun main(args: Array<String!>!): Unit

class GossipApp

Module Contents

fun publish(message:

class HandshakeException : RuntimeException

)

Unit

interface HandshakeMessage

Module Contents

abstract fun ephemeralPublicKey(): PublicKey!

abstract fun nonce():

Module Contents

EVMC_TANGERINE_WHISTLE

static fun digestUsingAlgorithm(input: ByteArray!, alg: String!): ByteArray!

class Hash

Module Contents

static fun digestUsingAlgorithm(input:

alg

String

)

static fun keccak256(input: ByteArray!): ByteArray!

static fun keccak256(input:

)

static fun keccak512(input: ByteArray!): ByteArray!

static fun keccak512(input:

)

static fun sha2_256(input: ByteArray!): ByteArray!

static fun sha2_256(input:

)

static fun sha2_512_256(input: ByteArray!): ByteArray!

static fun sha2_512_256(input:

)

static fun sha3_256(input: ByteArray!): ByteArray!

static fun sha3_256(input:

)

static fun sha3_512(input: ByteArray!): ByteArray!

static fun sha3_512(input:

)

Module Contents

)

)

static fun hash(value:

)

class HelloMessage : WireProtocolMessage

Module Contents

fun capabilities(): MutableList<Capability!>!

fun clientId(): String!

fun messageType(): Int

fun p2pVersion(): Int

class HMACSHA256

Module Contents

key

Key

)

static fun authenticate(message: ByteArray!, key: Key!): ByteArray!

Module Contents

)

Key

static fun verify(authenticator: ByteArray!, in: ByteArray!, key: Key!): Boolean

key

Key

)

Boolean

class HMACSHA512

Module Contents

key

Key

)

static fun authenticate(message: ByteArray!, key: Key!): ByteArray!

Module Contents

)

Key

static fun verify(authenticator: ByteArray!, in: ByteArray!, key: Key!): Boolean

key

Key

)

Boolean

class HMACSHA512256

Module Contents

key

Key

)

static fun authenticate(message: ByteArray!, key: Key!): ByteArray!

Module Contents

)

Key

static fun verify(authenticator: ByteArray!, in: ByteArray!, key: Key!): Boolean

key

Key

)

Boolean

class HobbitsTransport : CoroutineScope

Module Contents

HobbitsTransport(vertx: Vertx, incompleteMessageHandler: (

)

Unit

coroutineContext

CoroutineContext

)

fun createHTTPEndpoint(id: String = "default", networkInterface: String = "0.0.0.0", port: Int = 9337, requestURI: String? = null, tls: Boolean = false, handler: (

fun createTCPEndpoint(id: String = "default", networkInterface: String = "0.0.0.0", port: Int = 9237, tls: Boolean = false, handler: (

)

Unit

portUpdateListener

(

Int

)

Unit

)

Unit

fun createUDPEndpoint(id: String = "default", networkInterface: String = "0.0.0.0", port: Int = 9137, handler: (

)

Unit

portUpdateListener

(

Int

)

Unit

)

Unit

fun createWSEndpoint(id: String = "default", networkInterface: String = "0.0.0.0", port: Int = 9037, requestURI: String? = null, tls: Boolean = false, handler: (

)

Unit

)

Unit

fun exceptionHandler(handler: (Throwable) -> Unit): Unit

)

Unit

portUpdateListener

(

Int

)

Unit

)

Unit

suspend fun sendMessage(message:

transport

Transport

host

String

port

Int

requestURI

String

)

Unit

@Component("htmlConfig") class HtmlConfig

Module Contents

HtmlConfig()

var maxETH: Long?

var requestMessage: String?

var title: String?

interface Identity

Module Contents

abstract fun activePeers(): List<

abstract fun id(): String

abstract fun publicKey(): PublicKey

Module Contents

Module Contents

abstract fun curve(): Curve!

open fun curveName(): String!

abstract fun ed25519PublicKey(): PublicKey!

open static fun fromPublicKey(publicKey: PublicKey!):

open static fun fromPublicKey(publicKey: PublicKey!):

open static fun fromSecretKey(secretKey: SecretKey!):

open static fun fromSecretKey(secretKey: SecretKey!):

abstract fun publicKeyAsBase64String(): String!

open static fun randomEd25519():

open static fun randomSECP256K1():

abstract fun secp256k1PublicKey(): PublicKey!

abstract fun sign(message:

)

open fun toCanonicalForm(): String!

abstract fun verify(signature:

message

class InfinispanKeyValueStore<K, V> :

)

Boolean

InfinispanKeyValueStore(cache: Cache<K, V>, coroutineContext: CoroutineContext = Dispatchers.IO)

Module Contents

@JvmStatic fun <K, V> open(cache: Cache<K, V>):

InfinispanKeyValueStore

class InvalidConfigurationPropertyTypeException : RuntimeException

Module Contents

open class InvalidMACException : RuntimeException

open class InvalidRLPEncodingException :

InvalidRLPEncodingException(message: String!)

Module Contents

open class InvalidRLPTypeException :

InvalidRLPTypeException(message: String!)

Module Contents

class InvalidSEC256K1SecretKeyStoreException : RuntimeException

Module Contents

InvalidSEC256K1SecretKeyStoreException()

open class InvalidSSZTypeException :

InvalidSSZTypeException(message: String!)

Module Contents

class Invite

Module Contents

Invite(host: String!, port: Int, identity:

static fun fromCanonicalForm(inviteCode: String!):

seedKey

Seed

)

@FunctionalInterface interface IOConsumer<T : Any!>

Module Contents

abstract fun accept(t: T): Unit

open class IsFollowingQuery

Module Contents

IsFollowingQuery()

IsFollowingQuery(source: String!, dest: String!)

open class IsFollowingResponse

Module Contents

IsFollowingResponse()

IsFollowingResponse(source: String!, destination: String!, following: Boolean)

open fun getDestination(): String!

open fun isFollowing(): Boolean

class JSONRPCClient : Closeable

Module Contents

JSONRPCClient(vertx: Vertx, serverPort: Int, serverHost: String)

val client: HttpClient!

suspend fun getBalance_latest(address:

)

suspend fun getTransactionCount_latest(address:

)

suspend fun sendRawTransaction(tx:

class KademliaRoutingTable<T> : Set<T>

)

String

val serverHost: String

val serverPort: Int

Module Contents

KademliaRoutingTable(selfId: ByteArray, k: Int, maxReplacements: Int = k, nodeId: (T) -> ByteArray, distanceToSelf: (T) -> Int = { nodeId(it) xorDist selfId })

fun add(node: T): T?

fun contains(element: T): Boolean

fun containsAll(elements: Collection<T>): Boolean

@JvmStatic fun <T> create(selfId: ByteArray, k: Int, nodeId: Function<T, ByteArray>, distanceToSelf: Function<T, Int>):

@JvmStatic fun <T> create(selfId: ByteArray, k: Int, maxReplacements: Int, nodeId: Function<T, ByteArray>, distanceToSelf: Function<T, Int>):

fun evict(node: T): Boolean

fun getRandom(): T

fun iterator(): Iterator<T>

fun logDistToSelf(node: T): Int

fun nearest(targetId: ByteArray, limit: Int): List<T>

fun peersOfDistance(value: Int): List<T>

static fun contextLength(): Int

class KeyDerivation

Module Contents

KeyDerivation()

class MasterKey : Destroyable

Module Contents

fun deriveKey(length: Int, subkeyId: Long, context: ByteArray!):

fun deriveKey(length: Int, subkeyId: Long, context: String!):

fun deriveKeyArray(length: Int, subkeyId: Long, context: ByteArray!): ByteArray!

fun deriveKeyArray(length: Int, subkeyId: Long, context: String!): ByteArray!

static fun fromBytes(bytes: ByteArray!): MasterKey!

)

MasterKey

static fun random(): MasterKey!

static fun maxSubKeyLength(): Int

static fun minSubKeyLength(): Int

class KeyExchange

Module Contents

KeyExchange()

static fun client(clientKeys: KeyPair!, serverKey: PublicKey!): SessionKeyPair!

KeyPair(publicKey: PublicKey!, secretKey: SecretKey!)

Module Contents

static fun forSecretKey(secretKey: SecretKey!): KeyPair!

Module Contents

static fun fromBytes(bytes: ByteArray!): PublicKey!

)

PublicKey

Module Contents

static fun fromBytes(bytes: ByteArray!): SecretKey!

)

SecretKey

Module Contents

)

Seed

static fun server(serverKeys: KeyPair!, clientKey: PublicKey!): SessionKeyPair!

class SessionKey : Destroyable

Module Contents

static fun fromBytes(bytes: ByteArray!): SessionKey!

)

SessionKey

SessionKeyPair(rxKey: SessionKey!, txKey: SessionKey!)

class SessionKeyPair

Module Contents

open static fun getLocalKeys(ssbFolder: Path!): KeyPair!

fun rx(): SessionKey!

fun tx(): SessionKey!

open class KeyFileLoader

Module Contents

open static fun loadKeysFromFile(secretPath: Path!): KeyPair!

Module Contents

interface KeyValueStore<K, V> : Closeable, CoroutineScope

Module Contents

abstract suspend fun clear(): Unit

open fun clearAsync():

abstract suspend fun containsKey(key: K): Boolean

open fun containsKeyAsync(key: K):

Boolean

abstract suspend fun keys(): Iterable<K>

open fun keysAsync():

abstract suspend fun put(key: K, value: V): Unit

Iterable

open fun putAsync(key: K, value: V):

infix fun ByteArray.xorDist(other: ByteArray): Int

kotlin.ByteArray

Module Contents

fun ByteArray.xorDistCmp(a: ByteArray, b: ByteArray): Int

kotlin.collections.MutableList

Module Contents

fun <E> MutableList<E>.orderedInsert(element: E, comparison: (E, E) -> Int): Unit

kotlinx.coroutines.CoroutineScope

Module Contents

fun CoroutineScope.asyncCompletion(context: CoroutineContext = Dispatchers.Default, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> Unit):

fun <T> CoroutineScope.asyncResult(context: CoroutineContext = Dispatchers.Default, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> T):

suspend fun <R> CoroutineScope.retry(retryDelay: Long, block: suspend (Int) -> R?): R

suspend fun <R> CoroutineScope.retry(retryDelay: Long, maxRetries: Int, block: suspend (Int) -> R?): R?

suspend fun <R> CoroutineScope.retry(retryDelay: (Int) -> Long?, block: suspend (Int) -> R?): R?

kotlinx.coroutines.Deferred

Module Contents

fun Deferred<Unit>.asAsyncCompletion():

fun <T> Deferred<T>.asAsyncResult():

fun Job.asAsyncCompletion():

kotlinx.coroutines.Job

Module Contents

class LESSubprotocol :

LESSubprotocol(coroutineContext: CoroutineContext = Dispatchers.Default, blockchainInfo:

Module Contents

serveHeaders

Boolean

serveChainSince

serveStateSince

flowControlBufferLimit

flowControlMaximumRequestCostTable

flowControlMinimumRateOfRecharge

repo

pendingTransactionsPool

listener

(

)

Unit

)

)

client

)

)

Boolean

class LevelDBKeyValueStore<K, V> :

LevelDBKeyValueStore(dbPath: Path, keySerializer: (K) ->

Module Contents

valueSerializer

(

)

keyDeserializer

(

)

valueDeserializer

(

)

options

Options

coroutineContext

CoroutineContext

)

@JvmStatic fun <K, V> open(dbPath: Path, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

)

@JvmStatic fun <K, V> open(dbPath: Path, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

options

Options

)

abstract fun _sodium_alloc_init(): Int

interface LibSodium

Module Contents

abstract fun _sodium_runtime_get_cpu_features(): Int

abstract fun buf(buf: ByteArray!, size: Long): Unit

abstract fun close(): Int

abstract fun crypto_aead_aes256gcm_abytes(): Long

abstract fun crypto_aead_aes256gcm_beforenm(ctx_: Pointer!, k: Pointer!): Int

abstract fun crypto_aead_aes256gcm_decrypt(m: ByteArray!, mlen_p: LongLongByReference!, nsec: Pointer!, c: ByteArray!, clen: Long, ad: ByteArray!, adlen: Long, npub: Pointer!, k: Pointer!): Int

abstract fun crypto_aead_aes256gcm_decrypt_afternm(m: ByteArray!, mlen_p: LongLongByReference!, nsec: Pointer!, c: ByteArray!, clen: Long, ad: ByteArray!, adlen: Long, npub: Pointer!, ctx_: Pointer!): Int

abstract fun crypto_aead_aes256gcm_decrypt_detached(m: ByteArray!, nsec: Pointer!, c: ByteArray!, clen: Long, mac: ByteArray!, ad: ByteArray!, adlen: Long, npub: Pointer!, k: Pointer!): Int

abstract fun crypto_aead_aes256gcm_decrypt_detached_afternm(m: ByteArray!, nsec: Pointer!, c: ByteArray!, clen: Long, mac: ByteArray!, ad: ByteArray!, adlen: Long, npub: Pointer!, ctx_: Pointer!): Int

abstract fun crypto_aead_aes256gcm_encrypt(c: ByteArray!, clen_p: LongLongByReference!, m: ByteArray!, mlen: Long, ad: ByteArray!, adlen: Long, nsec: Pointer!, npub: Pointer!, k: Pointer!): Int

abstract fun crypto_aead_aes256gcm_encrypt_afternm(c: ByteArray!, clen_p: LongLongByReference!, m: ByteArray!, mlen: Long, ad: ByteArray!, adlen: Long, nsec: Pointer!, npub: Pointer!, ctx_: Pointer!): Int

abstract fun crypto_aead_aes256gcm_encrypt_detached(c: ByteArray!, mac: ByteArray!, maclen_p: LongLongByReference!, m: ByteArray!, mlen: Long, ad: ByteArray!, adlen: Long, nsec: Pointer!, npub: Pointer!, k: Pointer!): Int

abstract fun crypto_aead_aes256gcm_encrypt_detached_afternm(c: ByteArray!, mac: ByteArray!, maclen_p: LongLongByReference!, m: ByteArray!, mlen: Long, ad: ByteArray!, adlen: Long, nsec: Pointer!, npub: Pointer!, ctx_: Pointer!): Int

abstract fun crypto_aead_aes256gcm_is_available(): Int

abstract fun crypto_aead_aes256gcm_keybytes(): Long

abstract fun crypto_aead_aes256gcm_keygen(k: Pointer!): Unit

abstract fun crypto_aead_aes256gcm_messagebytes_max(): Long

abstract fun crypto_aead_aes256gcm_npubbytes(): Long

abstract fun crypto_aead_aes256gcm_nsecbytes(): Long

abstract fun crypto_aead_aes256gcm_statebytes(): Long

abstract fun crypto_aead_chacha20poly1305_abytes(): Long

abstract fun crypto_aead_chacha20poly1305_decrypt(m: ByteArray!, mlen_p: LongLongByReference!, nsec: ByteArray!, c: ByteArray!, clen: Long, ad: ByteArray!, adlen: Long, npub: ByteArray!, k: ByteArray!): Int

abstract fun crypto_aead_chacha20poly1305_decrypt_detached(m: ByteArray!, nsec: ByteArray!, c: ByteArray!, clen: Long, mac: ByteArray!, ad: ByteArray!, adlen: Long, npub: ByteArray!, k: ByteArray!): Int

abstract fun crypto_aead_chacha20poly1305_encrypt(c: ByteArray!, clen_p: LongLongByReference!, m: ByteArray!, mlen: Long, ad: ByteArray!, adlen: Long, nsec: ByteArray!, npub: ByteArray!, k: ByteArray!): Int

abstract fun crypto_aead_chacha20poly1305_encrypt_detached(c: ByteArray!, mac: ByteArray!, maclen_p: LongLongByReference!, m: ByteArray!, mlen: Long, ad: ByteArray!, adlen: Long, nsec: ByteArray!, npub: ByteArray!, k: ByteArray!): Int

abstract fun crypto_aead_chacha20poly1305_ietf_abytes(): Long

abstract fun crypto_aead_chacha20poly1305_ietf_decrypt(m: ByteArray!, mlen_p: LongLongByReference!, nsec: ByteArray!, c: ByteArray!, clen: Long, ad: ByteArray!, adlen: Long, npub: ByteArray!, k: ByteArray!): Int

abstract fun crypto_aead_chacha20poly1305_ietf_decrypt_detached(m: ByteArray!, nsec: ByteArray!, c: ByteArray!, clen: Long, mac: ByteArray!, ad: ByteArray!, adlen: Long, npub: ByteArray!, k: ByteArray!): Int

abstract fun crypto_aead_chacha20poly1305_ietf_encrypt(c: ByteArray!, clen_p: LongLongByReference!, m: ByteArray!, mlen: Long, ad: ByteArray!, adlen: Long, nsec: ByteArray!, npub: ByteArray!, k: ByteArray!): Int

abstract fun crypto_aead_chacha20poly1305_ietf_encrypt_detached(c: ByteArray!, mac: ByteArray!, maclen_p: LongLongByReference!, m: ByteArray!, mlen: Long, ad: ByteArray!, adlen: Long, nsec: ByteArray!, npub: ByteArray!, k: ByteArray!): Int

abstract fun crypto_aead_chacha20poly1305_ietf_keybytes(): Long

abstract fun crypto_aead_chacha20poly1305_ietf_keygen(k: ByteArray!): Unit

abstract fun crypto_aead_chacha20poly1305_ietf_messagebytes_max(): Long

abstract fun crypto_aead_chacha20poly1305_ietf_npubbytes(): Long

abstract fun crypto_aead_chacha20poly1305_ietf_nsecbytes(): Long

abstract fun crypto_aead_chacha20poly1305_keybytes(): Long

abstract fun crypto_aead_chacha20poly1305_keygen(k: ByteArray!): Unit

abstract fun crypto_aead_chacha20poly1305_messagebytes_max(): Long

abstract fun crypto_aead_chacha20poly1305_npubbytes(): Long

abstract fun crypto_aead_chacha20poly1305_nsecbytes(): Long

abstract fun crypto_aead_xchacha20poly1305_ietf_abytes(): Long

abstract fun crypto_aead_xchacha20poly1305_ietf_decrypt(m: ByteArray!, mlen_p: LongLongByReference!, nsec: ByteArray!, c: ByteArray!, clen: Long, ad: ByteArray!, adlen: Long, npub: Pointer!, k: Pointer!): Int

abstract fun crypto_aead_xchacha20poly1305_ietf_decrypt_detached(m: ByteArray!, nsec: ByteArray!, c: ByteArray!, clen: Long, mac: ByteArray!, ad: ByteArray!, adlen: Long, npub: Pointer!, k: Pointer!): Int

abstract fun crypto_aead_xchacha20poly1305_ietf_encrypt(c: ByteArray!, clen_p: LongLongByReference!, m: ByteArray!, mlen: Long, ad: ByteArray!, adlen: Long, nsec: ByteArray!, npub: Pointer!, k: Pointer!): Int

abstract fun crypto_aead_xchacha20poly1305_ietf_encrypt_detached(c: ByteArray!, mac: ByteArray!, maclen_p: LongLongByReference!, m: ByteArray!, mlen: Long, ad: ByteArray!, adlen: Long, nsec: ByteArray!, npub: Pointer!, k: Pointer!): Int

abstract fun crypto_aead_xchacha20poly1305_ietf_keybytes(): Long

abstract fun crypto_aead_xchacha20poly1305_ietf_keygen(k: Pointer!): Unit

abstract fun crypto_aead_xchacha20poly1305_ietf_messagebytes_max(): Long

abstract fun crypto_aead_xchacha20poly1305_ietf_npubbytes(): Long

abstract fun crypto_aead_xchacha20poly1305_ietf_nsecbytes(): Long

abstract fun crypto_auth(out: ByteArray!, in: ByteArray!, inlen: Long, k: Pointer!): Int

abstract fun crypto_auth_bytes(): Long

abstract fun crypto_auth_hmacsha256(out: ByteArray!, in: ByteArray!, inlen: Long, k: Pointer!): Int

abstract fun crypto_auth_hmacsha256_bytes(): Long

abstract fun crypto_auth_hmacsha256_final(state: Pointer!, out: ByteArray!): Int

abstract fun crypto_auth_hmacsha256_init(state: Pointer!, key: ByteArray!, keylen: Long): Int

abstract fun crypto_auth_hmacsha256_keybytes(): Long

abstract fun crypto_auth_hmacsha256_keygen(k: ByteArray!): Unit

abstract fun crypto_auth_hmacsha256_statebytes(): Long

abstract fun crypto_auth_hmacsha256_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_auth_hmacsha256_verify(h: ByteArray!, in: ByteArray!, inlen: Long, k: Pointer!): Int

abstract fun crypto_auth_hmacsha512(out: ByteArray!, in: ByteArray!, inlen: Long, k: Pointer!): Int

abstract fun crypto_auth_hmacsha512256(out: ByteArray!, in: ByteArray!, inlen: Long, k: Pointer!): Int

abstract fun crypto_auth_hmacsha512256_bytes(): Long

abstract fun crypto_auth_hmacsha512256_final(state: Pointer!, out: ByteArray!): Int

abstract fun crypto_auth_hmacsha512256_init(state: Pointer!, key: ByteArray!, keylen: Long): Int

abstract fun crypto_auth_hmacsha512256_keybytes(): Long

abstract fun crypto_auth_hmacsha512256_keygen(k: ByteArray!): Unit

abstract fun crypto_auth_hmacsha512256_statebytes(): Long

abstract fun crypto_auth_hmacsha512256_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_auth_hmacsha512256_verify(h: ByteArray!, in: ByteArray!, inlen: Long, k: Pointer!): Int

abstract fun crypto_auth_hmacsha512_bytes(): Long

abstract fun crypto_auth_hmacsha512_final(state: Pointer!, out: ByteArray!): Int

abstract fun crypto_auth_hmacsha512_init(state: Pointer!, key: ByteArray!, keylen: Long): Int

abstract fun crypto_auth_hmacsha512_keybytes(): Long

abstract fun crypto_auth_hmacsha512_keygen(k: ByteArray!): Unit

abstract fun crypto_auth_hmacsha512_statebytes(): Long

abstract fun crypto_auth_hmacsha512_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_auth_hmacsha512_verify(h: ByteArray!, in: ByteArray!, inlen: Long, k: Pointer!): Int

abstract fun crypto_auth_keybytes(): Long

abstract fun crypto_auth_keygen(k: Pointer!): Unit

abstract fun crypto_auth_primitive(): String!

abstract fun crypto_auth_verify(h: ByteArray!, in: ByteArray!, inlen: Long, k: Pointer!): Int

abstract fun crypto_box(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_afternm(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: Pointer!): Int

abstract fun crypto_box_beforenm(k: Pointer!, pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_box_beforenmbytes(): Long

abstract fun crypto_box_boxzerobytes(): Long

abstract fun crypto_box_curve25519xchacha20poly1305_beforenm(k: Pointer!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_beforenmbytes(): Long

abstract fun crypto_box_curve25519xchacha20poly1305_detached(c: ByteArray!, mac: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_detached_afternm(c: ByteArray!, mac: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: Pointer!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_easy(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_easy_afternm(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: Pointer!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_keypair(pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_macbytes(): Long

abstract fun crypto_box_curve25519xchacha20poly1305_messagebytes_max(): Long

abstract fun crypto_box_curve25519xchacha20poly1305_noncebytes(): Long

abstract fun crypto_box_curve25519xchacha20poly1305_open_detached(m: ByteArray!, c: ByteArray!, mac: ByteArray!, clen: Long, n: ByteArray!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_open_detached_afternm(m: ByteArray!, c: ByteArray!, mac: ByteArray!, clen: Long, n: ByteArray!, k: Pointer!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_open_easy(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_open_easy_afternm(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, k: Pointer!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_publickeybytes(): Long

abstract fun crypto_box_curve25519xchacha20poly1305_seal(c: ByteArray!, m: ByteArray!, mlen: Long, pk: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_seal_open(m: ByteArray!, c: ByteArray!, clen: Long, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_sealbytes(): Long

abstract fun crypto_box_curve25519xchacha20poly1305_secretkeybytes(): Long

abstract fun crypto_box_curve25519xchacha20poly1305_seed_keypair(pk: ByteArray!, sk: ByteArray!, seed: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_seedbytes(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xsalsa20poly1305_afternm(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: Pointer!): Int

abstract fun crypto_box_curve25519xsalsa20poly1305_beforenm(k: Pointer!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xsalsa20poly1305_beforenmbytes(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305_boxzerobytes(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305_keypair(pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xsalsa20poly1305_macbytes(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305_messagebytes_max(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305_noncebytes(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305_open(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xsalsa20poly1305_open_afternm(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, k: Pointer!): Int

abstract fun crypto_box_curve25519xsalsa20poly1305_publickeybytes(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305_secretkeybytes(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305_seed_keypair(pk: ByteArray!, sk: ByteArray!, seed: ByteArray!): Int

abstract fun crypto_box_curve25519xsalsa20poly1305_seedbytes(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305_zerobytes(): Long

abstract fun crypto_box_detached(c: ByteArray!, mac: ByteArray!, m: ByteArray!, mlen: Long, n: Pointer!, pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_box_detached_afternm(c: ByteArray!, mac: ByteArray!, m: ByteArray!, mlen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_box_easy(c: ByteArray!, m: ByteArray!, mlen: Long, n: Pointer!, pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_box_easy_afternm(c: ByteArray!, m: ByteArray!, mlen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_box_keypair(pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_box_macbytes(): Long

abstract fun crypto_box_messagebytes_max(): Long

abstract fun crypto_box_noncebytes(): Long

abstract fun crypto_box_open(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_open_afternm(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, k: Pointer!): Int

abstract fun crypto_box_open_detached(m: ByteArray!, c: ByteArray!, mac: ByteArray!, clen: Long, n: Pointer!, pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_box_open_detached_afternm(m: ByteArray!, c: ByteArray!, mac: ByteArray!, clen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_box_open_easy(m: ByteArray!, c: ByteArray!, clen: Long, n: Pointer!, pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_box_open_easy_afternm(m: ByteArray!, c: ByteArray!, clen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_box_primitive(): String!

abstract fun crypto_box_publickeybytes(): Long

abstract fun crypto_box_seal(c: ByteArray!, m: ByteArray!, mlen: Long, pk: Pointer!): Int

abstract fun crypto_box_seal_open(m: ByteArray!, c: ByteArray!, clen: Long, pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_box_sealbytes(): Long

abstract fun crypto_box_secretkeybytes(): Long

abstract fun crypto_box_seed_keypair(pk: Pointer!, sk: Pointer!, seed: Pointer!): Int

abstract fun crypto_box_seedbytes(): Long

abstract fun crypto_box_zerobytes(): Long

abstract fun crypto_core_ed25519_add(r: ByteArray!, p: ByteArray!, q: ByteArray!): Int

abstract fun crypto_core_ed25519_bytes(): Long

abstract fun crypto_core_ed25519_from_hash(p: ByteArray!, h: ByteArray!): Int

abstract fun crypto_core_ed25519_from_uniform(p: ByteArray!, r: ByteArray!): Int

abstract fun crypto_core_ed25519_hashbytes(): Long

abstract fun crypto_core_ed25519_is_valid_point(p: ByteArray!): Int

abstract fun crypto_core_ed25519_nonreducedscalarbytes(): Long

abstract fun crypto_core_ed25519_random(p: ByteArray!): Unit

abstract fun crypto_core_ed25519_scalar_add(z: ByteArray!, x: ByteArray!, y: ByteArray!): Unit

abstract fun crypto_core_ed25519_scalar_complement(comp: ByteArray!, s: ByteArray!): Unit

abstract fun crypto_core_ed25519_scalar_invert(recip: ByteArray!, s: ByteArray!): Int

abstract fun crypto_core_ed25519_scalar_mul(z: ByteArray!, x: ByteArray!, y: ByteArray!): Unit

abstract fun crypto_core_ed25519_scalar_negate(neg: ByteArray!, s: ByteArray!): Unit

abstract fun crypto_core_ed25519_scalar_random(r: ByteArray!): Unit

abstract fun crypto_core_ed25519_scalar_reduce(r: ByteArray!, s: ByteArray!): Unit

abstract fun crypto_core_ed25519_scalar_sub(z: ByteArray!, x: ByteArray!, y: ByteArray!): Unit

abstract fun crypto_core_ed25519_scalarbytes(): Long

abstract fun crypto_core_ed25519_sub(r: ByteArray!, p: ByteArray!, q: ByteArray!): Int

abstract fun crypto_core_ed25519_uniformbytes(): Long

abstract fun crypto_core_hchacha20(out: ByteArray!, in: ByteArray!, k: ByteArray!, c: ByteArray!): Int

abstract fun crypto_core_hchacha20_constbytes(): Long

abstract fun crypto_core_hchacha20_inputbytes(): Long

abstract fun crypto_core_hchacha20_keybytes(): Long

abstract fun crypto_core_hchacha20_outputbytes(): Long

abstract fun crypto_core_hsalsa20(out: ByteArray!, in: ByteArray!, k: ByteArray!, c: ByteArray!): Int

abstract fun crypto_core_hsalsa20_constbytes(): Long

abstract fun crypto_core_hsalsa20_inputbytes(): Long

abstract fun crypto_core_hsalsa20_keybytes(): Long

abstract fun crypto_core_hsalsa20_outputbytes(): Long

abstract fun crypto_core_ristretto255_add(r: ByteArray!, p: ByteArray!, q: ByteArray!): Int

abstract fun crypto_core_ristretto255_bytes(): Long

abstract fun crypto_core_ristretto255_from_hash(p: ByteArray!, r: ByteArray!): Int

abstract fun crypto_core_ristretto255_hashbytes(): Long

abstract fun crypto_core_ristretto255_is_valid_point(p: ByteArray!): Int

abstract fun crypto_core_ristretto255_nonreducedscalarbytes(): Long

abstract fun crypto_core_ristretto255_random(p: ByteArray!): Unit

abstract fun crypto_core_ristretto255_scalar_add(z: ByteArray!, x: ByteArray!, y: ByteArray!): Unit

abstract fun crypto_core_ristretto255_scalar_complement(comp: ByteArray!, s: ByteArray!): Unit

abstract fun crypto_core_ristretto255_scalar_invert(recip: ByteArray!, s: ByteArray!): Int

abstract fun crypto_core_ristretto255_scalar_mul(z: ByteArray!, x: ByteArray!, y: ByteArray!): Unit

abstract fun crypto_core_ristretto255_scalar_negate(neg: ByteArray!, s: ByteArray!): Unit

abstract fun crypto_core_ristretto255_scalar_random(r: ByteArray!): Unit

abstract fun crypto_core_ristretto255_scalar_reduce(r: ByteArray!, s: ByteArray!): Unit

abstract fun crypto_core_ristretto255_scalar_sub(z: ByteArray!, x: ByteArray!, y: ByteArray!): Unit

abstract fun crypto_core_ristretto255_scalarbytes(): Long

abstract fun crypto_core_ristretto255_sub(r: ByteArray!, p: ByteArray!, q: ByteArray!): Int

abstract fun crypto_core_salsa20(out: ByteArray!, in: ByteArray!, k: ByteArray!, c: ByteArray!): Int

abstract fun crypto_core_salsa2012(out: ByteArray!, in: ByteArray!, k: ByteArray!, c: ByteArray!): Int

abstract fun crypto_core_salsa2012_constbytes(): Long

abstract fun crypto_core_salsa2012_inputbytes(): Long

abstract fun crypto_core_salsa2012_keybytes(): Long

abstract fun crypto_core_salsa2012_outputbytes(): Long

abstract fun crypto_core_salsa208(out: ByteArray!, in: ByteArray!, k: ByteArray!, c: ByteArray!): Int

abstract fun crypto_core_salsa208_constbytes(): Long

abstract fun crypto_core_salsa208_inputbytes(): Long

abstract fun crypto_core_salsa208_keybytes(): Long

abstract fun crypto_core_salsa208_outputbytes(): Long

abstract fun crypto_core_salsa20_constbytes(): Long

abstract fun crypto_core_salsa20_inputbytes(): Long

abstract fun crypto_core_salsa20_keybytes(): Long

abstract fun crypto_core_salsa20_outputbytes(): Long

abstract fun crypto_generichash(out: Pointer!, outlen: Long, in: Pointer!, inlen: Long, key: Pointer!, keylen: Long): Int

abstract fun crypto_generichash_blake2b(out: ByteArray!, outlen: Long, in: ByteArray!, inlen: Long, key: ByteArray!, keylen: Long): Int

abstract fun crypto_generichash_blake2b_bytes(): Long

abstract fun crypto_generichash_blake2b_bytes_max(): Long

abstract fun crypto_generichash_blake2b_bytes_min(): Long

abstract fun crypto_generichash_blake2b_final(state: Pointer!, out: ByteArray!, outlen: Long): Int

abstract fun crypto_generichash_blake2b_init(state: Pointer!, key: ByteArray!, keylen: Long, outlen: Long): Int

abstract fun crypto_generichash_blake2b_init_salt_personal(state: Pointer!, key: ByteArray!, keylen: Long, outlen: Long, salt: ByteArray!, personal: ByteArray!): Int

abstract fun crypto_generichash_blake2b_keybytes(): Long

abstract fun crypto_generichash_blake2b_keybytes_max(): Long

abstract fun crypto_generichash_blake2b_keybytes_min(): Long

abstract fun crypto_generichash_blake2b_keygen(k: ByteArray!): Unit

abstract fun crypto_generichash_blake2b_personalbytes(): Long

abstract fun crypto_generichash_blake2b_salt_personal(out: ByteArray!, outlen: Long, in: ByteArray!, inlen: Long, key: ByteArray!, keylen: Long, salt: ByteArray!, personal: ByteArray!): Int

abstract fun crypto_generichash_blake2b_saltbytes(): Long

abstract fun crypto_generichash_blake2b_statebytes(): Long

abstract fun crypto_generichash_blake2b_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_generichash_bytes(): Long

abstract fun crypto_generichash_bytes_max(): Long

abstract fun crypto_generichash_bytes_min(): Long

abstract fun crypto_generichash_final(state: Pointer!, out: ByteArray!, outlen: Long): Int

abstract fun crypto_generichash_init(state: Pointer!, key: ByteArray!, keylen: Long, outlen: Long): Int

abstract fun crypto_generichash_keybytes(): Long

abstract fun crypto_generichash_keybytes_max(): Long

abstract fun crypto_generichash_keybytes_min(): Long

abstract fun crypto_generichash_keygen(k: ByteArray!): Unit

abstract fun crypto_generichash_primitive(): String!

abstract fun crypto_generichash_statebytes(): Long

abstract fun crypto_generichash_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_hash(out: ByteArray!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_hash_bytes(): Long

abstract fun crypto_hash_primitive(): String!

abstract fun crypto_hash_sha256(out: ByteArray!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_hash_sha256(out: Pointer!, in: Pointer!, inlen: Long): Int

abstract fun crypto_hash_sha256_bytes(): Long

abstract fun crypto_hash_sha256_final(state: Pointer!, out: ByteArray!): Int

abstract fun crypto_hash_sha256_init(state: Pointer!): Int

abstract fun crypto_hash_sha256_statebytes(): Long

abstract fun crypto_hash_sha256_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_hash_sha512(out: ByteArray!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_hash_sha512_bytes(): Long

abstract fun crypto_hash_sha512_final(state: Pointer!, out: ByteArray!): Int

abstract fun crypto_hash_sha512_init(state: Pointer!): Int

abstract fun crypto_hash_sha512_statebytes(): Long

abstract fun crypto_hash_sha512_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_kdf_blake2b_bytes_max(): Long

abstract fun crypto_kdf_blake2b_bytes_min(): Long

abstract fun crypto_kdf_blake2b_contextbytes(): Long

abstract fun crypto_kdf_blake2b_derive_from_key(subkey: ByteArray!, subkey_len: Long, subkey_id: Long, ctx: ByteArray!, key: Pointer!): Int

abstract fun crypto_kdf_blake2b_keybytes(): Long

abstract fun crypto_kdf_bytes_max(): Long

abstract fun crypto_kdf_bytes_min(): Long

abstract fun crypto_kdf_contextbytes(): Long

abstract fun crypto_kdf_derive_from_key(subkey: ByteArray!, subkey_len: Long, subkey_id: Long, ctx: ByteArray!, key: Pointer!): Int

abstract fun crypto_kdf_keybytes(): Long

abstract fun crypto_kdf_keygen(k: Pointer!): Unit

abstract fun crypto_kdf_primitive(): String!

abstract fun crypto_kx_client_session_keys(rx: Pointer!, tx: Pointer!, client_pk: Pointer!, client_sk: Pointer!, server_pk: Pointer!): Int

abstract fun crypto_kx_keypair(pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_kx_primitive(): String!

abstract fun crypto_kx_publickeybytes(): Long

abstract fun crypto_kx_secretkeybytes(): Long

abstract fun crypto_kx_seed_keypair(pk: Pointer!, sk: Pointer!, seed: Pointer!): Int

abstract fun crypto_kx_seedbytes(): Long

abstract fun crypto_kx_server_session_keys(rx: Pointer!, tx: Pointer!, server_pk: Pointer!, server_sk: Pointer!, client_pk: Pointer!): Int

abstract fun crypto_kx_sessionkeybytes(): Long

abstract fun crypto_onetimeauth(out: ByteArray!, in: ByteArray!, inlen: Long, k: ByteArray!): Int

abstract fun crypto_onetimeauth_bytes(): Long

abstract fun crypto_onetimeauth_final(state: Pointer!, out: ByteArray!): Int

abstract fun crypto_onetimeauth_init(state: Pointer!, key: ByteArray!): Int

abstract fun crypto_onetimeauth_keybytes(): Long

abstract fun crypto_onetimeauth_keygen(k: ByteArray!): Unit

abstract fun crypto_onetimeauth_poly1305(out: ByteArray!, in: ByteArray!, inlen: Long, k: ByteArray!): Int

abstract fun crypto_onetimeauth_poly1305_bytes(): Long

abstract fun crypto_onetimeauth_poly1305_final(state: Pointer!, out: ByteArray!): Int

abstract fun crypto_onetimeauth_poly1305_init(state: Pointer!, key: ByteArray!): Int

abstract fun crypto_onetimeauth_poly1305_keybytes(): Long

abstract fun crypto_onetimeauth_poly1305_keygen(k: ByteArray!): Unit

abstract fun crypto_onetimeauth_poly1305_statebytes(): Long

abstract fun crypto_onetimeauth_poly1305_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_onetimeauth_poly1305_verify(h: ByteArray!, in: ByteArray!, inlen: Long, k: ByteArray!): Int

abstract fun crypto_onetimeauth_primitive(): String!

abstract fun crypto_onetimeauth_statebytes(): Long

abstract fun crypto_onetimeauth_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_onetimeauth_verify(h: ByteArray!, in: ByteArray!, inlen: Long, k: ByteArray!): Int

abstract fun crypto_pwhash(out: ByteArray!, outlen: Long, passwd: ByteArray!, passwdlen: Long, salt: Pointer!, opslimit: Long, memlimit: Long, alg: Int): Int

abstract fun crypto_pwhash_alg_argon2i13(): Int

abstract fun crypto_pwhash_alg_argon2id13(): Int

abstract fun crypto_pwhash_alg_default(): Int

abstract fun crypto_pwhash_argon2i(out: ByteArray!, outlen: Long, passwd: ByteArray!, passwdlen: Long, salt: ByteArray!, opslimit: Long, memlimit: Long, alg: Int): Int

abstract fun crypto_pwhash_argon2i_alg_argon2i13(): Int

abstract fun crypto_pwhash_argon2i_bytes_max(): Long

abstract fun crypto_pwhash_argon2i_bytes_min(): Long

abstract fun crypto_pwhash_argon2i_memlimit_interactive(): Long

abstract fun crypto_pwhash_argon2i_memlimit_max(): Long

abstract fun crypto_pwhash_argon2i_memlimit_min(): Long

abstract fun crypto_pwhash_argon2i_memlimit_moderate(): Long

abstract fun crypto_pwhash_argon2i_memlimit_sensitive(): Long

abstract fun crypto_pwhash_argon2i_opslimit_interactive(): Long

abstract fun crypto_pwhash_argon2i_opslimit_max(): Long

abstract fun crypto_pwhash_argon2i_opslimit_min(): Long

abstract fun crypto_pwhash_argon2i_opslimit_moderate(): Long

abstract fun crypto_pwhash_argon2i_opslimit_sensitive(): Long

abstract fun crypto_pwhash_argon2i_passwd_max(): Long

abstract fun crypto_pwhash_argon2i_passwd_min(): Long

abstract fun crypto_pwhash_argon2i_saltbytes(): Long

abstract fun crypto_pwhash_argon2i_str(out: ByteArray!, passwd: ByteArray!, passwdlen: Long, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_argon2i_str_needs_rehash(str: ByteArray!, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_argon2i_str_verify(str: ByteArray!, passwd: ByteArray!, passwdlen: Long): Int

abstract fun crypto_pwhash_argon2i_strbytes(): Long

abstract fun crypto_pwhash_argon2i_strprefix(): String!

abstract fun crypto_pwhash_argon2id(out: ByteArray!, outlen: Long, passwd: ByteArray!, passwdlen: Long, salt: ByteArray!, opslimit: Long, memlimit: Long, alg: Int): Int

abstract fun crypto_pwhash_argon2id_alg_argon2id13(): Int

abstract fun crypto_pwhash_argon2id_bytes_max(): Long

abstract fun crypto_pwhash_argon2id_bytes_min(): Long

abstract fun crypto_pwhash_argon2id_memlimit_interactive(): Long

abstract fun crypto_pwhash_argon2id_memlimit_max(): Long

abstract fun crypto_pwhash_argon2id_memlimit_min(): Long

abstract fun crypto_pwhash_argon2id_memlimit_moderate(): Long

abstract fun crypto_pwhash_argon2id_memlimit_sensitive(): Long

abstract fun crypto_pwhash_argon2id_opslimit_interactive(): Long

abstract fun crypto_pwhash_argon2id_opslimit_max(): Long

abstract fun crypto_pwhash_argon2id_opslimit_min(): Long

abstract fun crypto_pwhash_argon2id_opslimit_moderate(): Long

abstract fun crypto_pwhash_argon2id_opslimit_sensitive(): Long

abstract fun crypto_pwhash_argon2id_passwd_max(): Long

abstract fun crypto_pwhash_argon2id_passwd_min(): Long

abstract fun crypto_pwhash_argon2id_saltbytes(): Long

abstract fun crypto_pwhash_argon2id_str(out: ByteArray!, passwd: ByteArray!, passwdlen: Long, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_argon2id_str_needs_rehash(str: ByteArray!, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_argon2id_str_verify(str: ByteArray!, passwd: ByteArray!, passwdlen: Long): Int

abstract fun crypto_pwhash_argon2id_strbytes(): Long

abstract fun crypto_pwhash_argon2id_strprefix(): String!

abstract fun crypto_pwhash_bytes_max(): Long

abstract fun crypto_pwhash_bytes_min(): Long

abstract fun crypto_pwhash_memlimit_interactive(): Long

abstract fun crypto_pwhash_memlimit_max(): Long

abstract fun crypto_pwhash_memlimit_min(): Long

abstract fun crypto_pwhash_memlimit_moderate(): Long

abstract fun crypto_pwhash_memlimit_sensitive(): Long

abstract fun crypto_pwhash_opslimit_interactive(): Long

abstract fun crypto_pwhash_opslimit_max(): Long

abstract fun crypto_pwhash_opslimit_min(): Long

abstract fun crypto_pwhash_opslimit_moderate(): Long

abstract fun crypto_pwhash_opslimit_sensitive(): Long

abstract fun crypto_pwhash_passwd_max(): Long

abstract fun crypto_pwhash_passwd_min(): Long

abstract fun crypto_pwhash_primitive(): String!

abstract fun crypto_pwhash_saltbytes(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256(out: ByteArray!, outlen: Long, passwd: ByteArray!, passwdlen: Long, salt: ByteArray!, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_scryptsalsa208sha256_bytes_max(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_bytes_min(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_ll(passwd: ByteArray!, passwdlen: Long, salt: ByteArray!, saltlen: Long, N: Long, r: Int, p: Int, buf: ByteArray!, buflen: Long): Int

abstract fun crypto_pwhash_scryptsalsa208sha256_memlimit_interactive(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_memlimit_max(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_memlimit_min(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_opslimit_interactive(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_opslimit_max(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_opslimit_min(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_passwd_max(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_passwd_min(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_saltbytes(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_str(out: ByteArray!, passwd: ByteArray!, passwdlen: Long, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_scryptsalsa208sha256_str_needs_rehash(str: ByteArray!, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_scryptsalsa208sha256_str_verify(str: ByteArray!, passwd: ByteArray!, passwdlen: Long): Int

abstract fun crypto_pwhash_scryptsalsa208sha256_strbytes(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_strprefix(): String!

abstract fun crypto_pwhash_str(out: ByteArray!, passwd: ByteArray!, passwdlen: Long, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_str_alg(out: ByteArray!, passwd: ByteArray!, passwdlen: Long, opslimit: Long, memlimit: Long, alg: Int): Int

abstract fun crypto_pwhash_str_needs_rehash(str: Pointer!, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_str_verify(str: Pointer!, passwd: ByteArray!, passwdlen: Long): Int

abstract fun crypto_pwhash_strbytes(): Long

abstract fun crypto_pwhash_strprefix(): String!

abstract fun crypto_scalarmult(q: Pointer!, n: Pointer!, p: Pointer!): Int

abstract fun crypto_scalarmult_base(q: Pointer!, n: Pointer!): Int

abstract fun crypto_scalarmult_bytes(): Long

abstract fun crypto_scalarmult_curve25519(q: ByteArray!, n: ByteArray!, p: ByteArray!): Int

abstract fun crypto_scalarmult_curve25519_base(q: ByteArray!, n: ByteArray!): Int

abstract fun crypto_scalarmult_curve25519_bytes(): Long

abstract fun crypto_scalarmult_curve25519_scalarbytes(): Long

abstract fun crypto_scalarmult_ed25519(q: ByteArray!, n: ByteArray!, p: ByteArray!): Int

abstract fun crypto_scalarmult_ed25519_base(q: ByteArray!, n: ByteArray!): Int

abstract fun crypto_scalarmult_ed25519_base_noclamp(q: ByteArray!, n: ByteArray!): Int

abstract fun crypto_scalarmult_ed25519_bytes(): Long

abstract fun crypto_scalarmult_ed25519_noclamp(q: ByteArray!, n: ByteArray!, p: ByteArray!): Int

abstract fun crypto_scalarmult_ed25519_scalarbytes(): Long

abstract fun crypto_scalarmult_primitive(): String!

abstract fun crypto_scalarmult_ristretto255(q: ByteArray!, n: ByteArray!, p: ByteArray!): Int

abstract fun crypto_scalarmult_ristretto255_base(q: ByteArray!, n: ByteArray!): Int

abstract fun crypto_scalarmult_ristretto255_bytes(): Long

abstract fun crypto_scalarmult_ristretto255_scalarbytes(): Long

abstract fun crypto_scalarmult_scalarbytes(): Long

abstract fun crypto_secretbox(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_secretbox_boxzerobytes(): Long

abstract fun crypto_secretbox_detached(c: ByteArray!, mac: ByteArray!, m: ByteArray!, mlen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_secretbox_easy(c: Pointer!, m: Pointer!, mlen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_secretbox_easy(c: ByteArray!, m: ByteArray!, mlen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_secretbox_keybytes(): Long

abstract fun crypto_secretbox_keygen(k: Pointer!): Unit

abstract fun crypto_secretbox_macbytes(): Long

abstract fun crypto_secretbox_messagebytes_max(): Long

abstract fun crypto_secretbox_noncebytes(): Long

abstract fun crypto_secretbox_open(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_secretbox_open_detached(m: ByteArray!, c: ByteArray!, mac: ByteArray!, clen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_secretbox_open_easy(m: ByteArray!, c: ByteArray!, clen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_secretbox_open_easy(m: Pointer!, c: Pointer!, clen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_secretbox_primitive(): String!

abstract fun crypto_secretbox_xchacha20poly1305_detached(c: ByteArray!, mac: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_secretbox_xchacha20poly1305_easy(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_secretbox_xchacha20poly1305_keybytes(): Long

abstract fun crypto_secretbox_xchacha20poly1305_macbytes(): Long

abstract fun crypto_secretbox_xchacha20poly1305_messagebytes_max(): Long

abstract fun crypto_secretbox_xchacha20poly1305_noncebytes(): Long

abstract fun crypto_secretbox_xchacha20poly1305_open_detached(m: ByteArray!, c: ByteArray!, mac: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_secretbox_xchacha20poly1305_open_easy(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_secretbox_xsalsa20poly1305(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_secretbox_xsalsa20poly1305_boxzerobytes(): Long

abstract fun crypto_secretbox_xsalsa20poly1305_keybytes(): Long

abstract fun crypto_secretbox_xsalsa20poly1305_keygen(k: ByteArray!): Unit

abstract fun crypto_secretbox_xsalsa20poly1305_macbytes(): Long

abstract fun crypto_secretbox_xsalsa20poly1305_messagebytes_max(): Long

abstract fun crypto_secretbox_xsalsa20poly1305_noncebytes(): Long

abstract fun crypto_secretbox_xsalsa20poly1305_open(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_secretbox_xsalsa20poly1305_zerobytes(): Long

abstract fun crypto_secretbox_zerobytes(): Long

abstract fun crypto_secretstream_xchacha20poly1305_abytes(): Long

abstract fun crypto_secretstream_xchacha20poly1305_headerbytes(): Long

abstract fun crypto_secretstream_xchacha20poly1305_init_pull(state: Pointer!, : ByteArray!, k: Pointer!): Int

abstract fun crypto_secretstream_xchacha20poly1305_init_push(state: Pointer!, : ByteArray!, k: Pointer!): Int

abstract fun crypto_secretstream_xchacha20poly1305_keybytes(): Long

abstract fun crypto_secretstream_xchacha20poly1305_keygen(k: Pointer!): Unit

abstract fun crypto_secretstream_xchacha20poly1305_messagebytes_max(): Long

abstract fun crypto_secretstream_xchacha20poly1305_pull(state: Pointer!, m: ByteArray!, mlen_p: LongLongByReference!, tag_p: ByteByReference!, c: ByteArray!, clen: Long, ad: ByteArray!, adlen: Long): Int

abstract fun crypto_secretstream_xchacha20poly1305_push(state: Pointer!, c: ByteArray!, clen_p: LongLongByReference!, m: ByteArray!, mlen: Long, ad: ByteArray!, adlen: Long, tag: Byte): Int

abstract fun crypto_secretstream_xchacha20poly1305_rekey(state: Pointer!): Unit

abstract fun crypto_secretstream_xchacha20poly1305_statebytes(): Long

abstract fun crypto_secretstream_xchacha20poly1305_tag_final(): Char

abstract fun crypto_secretstream_xchacha20poly1305_tag_message(): Char

abstract fun crypto_secretstream_xchacha20poly1305_tag_push(): Char

abstract fun crypto_secretstream_xchacha20poly1305_tag_rekey(): Char

abstract fun crypto_shorthash(out: ByteArray!, in: ByteArray!, inlen: Long, k: ByteArray!): Int

abstract fun crypto_shorthash_bytes(): Long

abstract fun crypto_shorthash_keybytes(): Long

abstract fun crypto_shorthash_keygen(k: ByteArray!): Unit

abstract fun crypto_shorthash_primitive(): String!

abstract fun crypto_shorthash_siphash24(out: ByteArray!, in: ByteArray!, inlen: Long, k: ByteArray!): Int

abstract fun crypto_shorthash_siphash24_bytes(): Long

abstract fun crypto_shorthash_siphash24_keybytes(): Long

abstract fun crypto_shorthash_siphashx24(out: ByteArray!, in: ByteArray!, inlen: Long, k: ByteArray!): Int

abstract fun crypto_shorthash_siphashx24_bytes(): Long

abstract fun crypto_shorthash_siphashx24_keybytes(): Long

abstract fun crypto_sign(sm: ByteArray!, @Nullable smlen_p: LongLongByReference?, m: ByteArray!, mlen: Long, sk: Pointer!): Int

abstract fun crypto_sign_bytes(): Long

abstract fun crypto_sign_detached(sig: ByteArray!, @Nullable siglen_p: LongLongByReference?, m: ByteArray!, mlen: Long, sk: Pointer!): Int

abstract fun crypto_sign_detached(sig: Pointer!, @Nullable siglen_p: LongLongByReference?, m: Pointer!, mlen: Long, sk: Pointer!): Int

abstract fun crypto_sign_ed25519(sm: ByteArray!, smlen_p: LongLongByReference!, m: ByteArray!, mlen: Long, sk: ByteArray!): Int

abstract fun crypto_sign_ed25519_bytes(): Long

abstract fun crypto_sign_ed25519_detached(sig: ByteArray!, siglen_p: LongLongByReference!, m: ByteArray!, mlen: Long, sk: ByteArray!): Int

abstract fun crypto_sign_ed25519_keypair(pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_sign_ed25519_messagebytes_max(): Long

abstract fun crypto_sign_ed25519_open(m: ByteArray!, mlen_p: LongLongByReference!, sm: ByteArray!, smlen: Long, pk: ByteArray!): Int

abstract fun crypto_sign_ed25519_pk_to_curve25519(curve25519_pk: Pointer!, ed25519_pk: Pointer!): Int

abstract fun crypto_sign_ed25519_publickeybytes(): Long

abstract fun crypto_sign_ed25519_secretkeybytes(): Long

abstract fun crypto_sign_ed25519_seed_keypair(pk: ByteArray!, sk: ByteArray!, seed: ByteArray!): Int

abstract fun crypto_sign_ed25519_seedbytes(): Long

abstract fun crypto_sign_ed25519_sk_to_curve25519(curve25519_sk: Pointer!, ed25519_sk: Pointer!): Int

abstract fun crypto_sign_ed25519_sk_to_pk(pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_sign_ed25519_sk_to_seed(seed: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_sign_ed25519_verify_detached(sig: ByteArray!, m: ByteArray!, mlen: Long, pk: ByteArray!): Int

abstract fun crypto_sign_ed25519ph_final_create(state: Pointer!, sig: ByteArray!, siglen_p: LongLongByReference!, sk: ByteArray!): Int

abstract fun crypto_sign_ed25519ph_final_verify(state: Pointer!, sig: ByteArray!, pk: ByteArray!): Int

abstract fun crypto_sign_ed25519ph_init(state: Pointer!): Int

abstract fun crypto_sign_ed25519ph_statebytes(): Long

abstract fun crypto_sign_ed25519ph_update(state: Pointer!, m: ByteArray!, mlen: Long): Int

abstract fun crypto_sign_final_create(state: Pointer!, sig: ByteArray!, siglen_p: LongLongByReference!, sk: ByteArray!): Int

abstract fun crypto_sign_final_verify(state: Pointer!, sig: ByteArray!, pk: ByteArray!): Int

abstract fun crypto_sign_init(state: Pointer!): Int

abstract fun crypto_sign_keypair(pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_sign_messagebytes_max(): Long

abstract fun crypto_sign_open(m: ByteArray!, mlen_p: LongLongByReference!, sm: ByteArray!, smlen: Long, pk: Pointer!): Int

abstract fun crypto_sign_primitive(): String!

abstract fun crypto_sign_publickeybytes(): Long

abstract fun crypto_sign_secretkeybytes(): Long

abstract fun crypto_sign_seed_keypair(pk: Pointer!, sk: Pointer!, seed: Pointer!): Int

abstract fun crypto_sign_seedbytes(): Long

abstract fun crypto_sign_statebytes(): Long

abstract fun crypto_sign_update(state: Pointer!, m: ByteArray!, mlen: Long): Int

abstract fun crypto_sign_verify_detached(sig: Pointer!, m: Pointer!, mlen: Long, pk: Pointer!): Int

abstract fun crypto_sign_verify_detached(sig: ByteArray!, m: ByteArray!, mlen: Long, pk: Pointer!): Int

abstract fun crypto_stream(c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_chacha20(c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_chacha20_ietf(c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_chacha20_ietf_keybytes(): Long

abstract fun crypto_stream_chacha20_ietf_keygen(k: ByteArray!): Unit

abstract fun crypto_stream_chacha20_ietf_messagebytes_max(): Long

abstract fun crypto_stream_chacha20_ietf_noncebytes(): Long

abstract fun crypto_stream_chacha20_ietf_xor(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_chacha20_ietf_xor_ic(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, ic: Int, k: ByteArray!): Int

abstract fun crypto_stream_chacha20_keybytes(): Long

abstract fun crypto_stream_chacha20_keygen(k: ByteArray!): Unit

abstract fun crypto_stream_chacha20_messagebytes_max(): Long

abstract fun crypto_stream_chacha20_noncebytes(): Long

abstract fun crypto_stream_chacha20_xor(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_chacha20_xor_ic(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, ic: Long, k: ByteArray!): Int

abstract fun crypto_stream_keybytes(): Long

abstract fun crypto_stream_keygen(k: ByteArray!): Unit

abstract fun crypto_stream_messagebytes_max(): Long

abstract fun crypto_stream_noncebytes(): Long

abstract fun crypto_stream_primitive(): String!

abstract fun crypto_stream_salsa20(c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_salsa2012(c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_salsa2012_keybytes(): Long

abstract fun crypto_stream_salsa2012_keygen(k: ByteArray!): Unit

abstract fun crypto_stream_salsa2012_messagebytes_max(): Long

abstract fun crypto_stream_salsa2012_noncebytes(): Long

abstract fun crypto_stream_salsa2012_xor(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_salsa208(c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_salsa208_keybytes(): Long

abstract fun crypto_stream_salsa208_keygen(k: ByteArray!): Unit

abstract fun crypto_stream_salsa208_messagebytes_max(): Long

abstract fun crypto_stream_salsa208_noncebytes(): Long

abstract fun crypto_stream_salsa208_xor(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_salsa20_keybytes(): Long

abstract fun crypto_stream_salsa20_keygen(k: ByteArray!): Unit

abstract fun crypto_stream_salsa20_messagebytes_max(): Long

abstract fun crypto_stream_salsa20_noncebytes(): Long

abstract fun crypto_stream_salsa20_xor(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_salsa20_xor_ic(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, ic: Long, k: ByteArray!): Int

abstract fun crypto_stream_xchacha20(c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_xchacha20_keybytes(): Long

abstract fun crypto_stream_xchacha20_keygen(k: ByteArray!): Unit

abstract fun crypto_stream_xchacha20_messagebytes_max(): Long

abstract fun crypto_stream_xchacha20_noncebytes(): Long

abstract fun crypto_stream_xchacha20_xor(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_xchacha20_xor_ic(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, ic: Long, k: ByteArray!): Int

abstract fun crypto_stream_xor(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_xsalsa20(c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_xsalsa20_keybytes(): Long

abstract fun crypto_stream_xsalsa20_keygen(k: ByteArray!): Unit

abstract fun crypto_stream_xsalsa20_messagebytes_max(): Long

abstract fun crypto_stream_xsalsa20_noncebytes(): Long

abstract fun crypto_stream_xsalsa20_xor(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_xsalsa20_xor_ic(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, ic: Long, k: ByteArray!): Int

abstract fun crypto_verify_16(x: ByteArray!, y: ByteArray!): Int

abstract fun crypto_verify_16_bytes(): Long

abstract fun crypto_verify_32(x: ByteArray!, y: ByteArray!): Int

abstract fun crypto_verify_32_bytes(): Long

abstract fun crypto_verify_64(x: ByteArray!, y: ByteArray!): Int

abstract fun crypto_verify_64_bytes(): Long

abstract fun implementation_name(): String!

abstract fun random(): Int

abstract fun randombytes(buf: ByteArray!, buf_len: Long): Unit

abstract fun randombytes_buf(buf: Pointer!, size: Long): Unit

abstract fun randombytes_buf_deterministic(buf: ByteArray!, size: Long, seed: ByteArray!): Unit

abstract fun randombytes_close(): Int

abstract fun randombytes_implementation_name(): String!

abstract fun randombytes_random(): Int

abstract fun randombytes_seedbytes(): Long

abstract fun randombytes_set_implementation(impl: Pointer!): Int

abstract fun randombytes_stir(): Unit

abstract fun randombytes_uniform(upper_bound: Int): Int

abstract fun sodium_add(a: Pointer!, b: Pointer!, len: Long): Unit

abstract fun sodium_allocarray(count: Long, size: Long): Pointer!

abstract fun sodium_base642bin(bin: ByteArray!, bin_maxlen: Long, b64: ByteArray!, b64_len: Long, ignore: ByteArray!, bin_len: LongLongByReference!, b64_end: Pointer!, variant: Int): Int

abstract fun sodium_base64_encoded_len(bin_len: Long, variant: Int): Long

abstract fun sodium_compare(b1_: Pointer!, b2_: Pointer!, len: Long): Int

abstract fun sodium_free(ptr: Pointer!): Unit

abstract fun sodium_hex2bin(bin: ByteArray!, bin_maxlen: Long, hex: ByteArray!, hex_len: Long, ignore: ByteArray!, bin_len: LongLongByReference!, hex_end: Pointer!): Int

abstract fun sodium_increment(n: Pointer!, nlen: Long): Unit

abstract fun sodium_init(): Int

abstract fun sodium_is_zero(n: Pointer!, nlen: Long): Int

abstract fun sodium_library_minimal(): Int

abstract fun sodium_library_version_major(): Int

abstract fun sodium_library_version_minor(): Int

abstract fun sodium_malloc(size: Long): Pointer!

abstract fun sodium_memcmp(b1_: Pointer!, b2_: Pointer!, len: Long): Int

abstract fun sodium_memzero(pnt: Pointer!, len: Long): Unit

abstract fun sodium_misuse(): Unit

abstract fun sodium_mlock(addr: Pointer!, len: Long): Int

abstract fun sodium_mprotect_noaccess(ptr: Pointer!): Int

abstract fun sodium_mprotect_readonly(ptr: Pointer!): Int

abstract fun sodium_mprotect_readwrite(ptr: Pointer!): Int

abstract fun sodium_munlock(addr: Pointer!, len: Long): Int

abstract fun sodium_pad(padded_buflen_p: LongLongByReference!, buf: ByteArray!, unpadded_buflen: Long, blocksize: Long, max_buflen: Long): Int

abstract fun sodium_runtime_has_aesni(): Int

abstract fun sodium_runtime_has_avx(): Int

abstract fun sodium_runtime_has_avx2(): Int

abstract fun sodium_runtime_has_avx512f(): Int

abstract fun sodium_runtime_has_neon(): Int

abstract fun sodium_runtime_has_pclmul(): Int

abstract fun sodium_runtime_has_rdrand(): Int

abstract fun sodium_runtime_has_sse2(): Int

abstract fun sodium_runtime_has_sse3(): Int

abstract fun sodium_runtime_has_sse41(): Int

abstract fun sodium_runtime_has_ssse3(): Int

abstract fun sodium_set_misuse_handler(handler: Pointer!): Int

abstract fun sodium_stackzero(len: Long): Unit

abstract fun sodium_sub(a: ByteArray!, b: ByteArray!, len: Long): Unit

abstract fun sodium_unpad(unpadded_buflen_p: LongLongByReference!, buf: ByteArray!, padded_buflen: Long, blocksize: Long): Int

abstract fun sodium_version_string(): String!

abstract fun stir(): Unit

abstract fun uniform(upper_bound: Int): Int

class LocalIdentity

Module Contents

LocalIdentity(ip: String!, port: String!, id:

LocalIdentity(ip: String!, port: Int, id:

)

LocalIdentity(addr: InetSocketAddress!, id:

)

)

static fun fromString(str: String!):

Module Contents

data

topics

MutableList

)

fun getTopics(): MutableList<

static fun readFrom(in:

)

)

Unit

class LogsBloomFilter

Module Contents

LogsBloomFilter()

LogsBloomFilter(data:

static fun compute(logs: MutableCollection<

)

)

)

Unit

fun insertLog(log:

static fun readFrom(input:

)

Unit

)

@Target([AnnotationTarget.VALUE_PARAMETER]) class LuceneIndex

Module Contents

LuceneIndex()

@Target([AnnotationTarget.VALUE_PARAMETER]) class LuceneIndexWriter

Module Contents

LuceneIndexWriter()

open class LuceneIndexWriterExtension : ParameterResolver, AfterAllCallback

Module Contents

LuceneIndexWriterExtension()

open fun afterAll(context: ExtensionContext!): Unit

open fun resolveParameter(parameterContext: ParameterContext!, extensionContext: ExtensionContext!): Any!

open fun supportsParameter(parameterContext: ParameterContext!, extensionContext: ExtensionContext!): Boolean

open class MalformedInviteCodeException : RuntimeException

Module Contents

MalformedInviteCodeException(message: String!)

class MapDBKeyValueStore<K, V> :

MapDBKeyValueStore(dbPath: Path, keySerializer: (K) ->

Module Contents

valueSerializer

(

)

keyDeserializer

(

)

valueDeserializer

(

)

coroutineContext

CoroutineContext

)

@JvmStatic fun <K, V> open(dbPath: Path, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

)

class MapKeyValueStore<K, V> :

MapKeyValueStore(map: MutableMap<K, V> = HashMap(), coroutineContext: CoroutineContext = Dispatchers.IO)

Module Contents

@JvmStatic fun <K, V> open():

@JvmStatic fun <K, V> open(map: MutableMap<K, V>):

class MemoryPeerRepository :

Module Contents

MemoryPeerRepository()

fun addConnection(peer:

identity

val connections: ConcurrentHashMap<String,

)

Unit

val identities: HashSet<

fun markConnectionInactive(peer:

identity

fun peerDiscoveredAt(peer:

)

Unit

val peerMap: ConcurrentHashMap<

time

Long

)

Unit

fun storeIdentity(networkInterface: String, port: Int, publicKey: PublicKey):

fun storePeer(id:

lastContacted

Instant

lastDiscovered

Instant

)

class MemoryTransactionPool :

suspend fun add(transaction:

Module Contents

MemoryTransactionPool()

suspend fun contains(hash:

)

Unit

open class MemoryWireConnectionsRepository :

)

Boolean

suspend fun get(hash:

)

MemoryWireConnectionsRepository()

Module Contents

open fun add(wireConnection:

open fun addConnectionListener(listener: Listener!): Unit

)

String

open fun addDisconnectionListener(listener: Listener!): Unit

open fun asIterable(): MutableIterable<

open fun asIterable(identifier:

)

MutableIterable

open fun asMap(): MutableMap<String!,

open fun get(id: String!):

class MerklePatriciaTrie<V> :

MerklePatriciaTrie(valueSerializer: (V) ->

Module Contents

@JvmStatic fun <V> create(valueSerializer: Function<V,

)

)

)

)

value

)

Unit

fun putAsync(key:

value

)

@JvmStatic fun storingBytes():

)

Unit

)

@JvmStatic fun storingStrings():

String

interface MerkleStorage

Module Contents

)

abstract suspend fun put(hash:

content

class MerkleStorageException : RuntimeException

)

Unit

Module Contents

MerkleStorageException(message: String)

MerkleStorageException(message: String, cause: Exception)

interface MerkleTrie<in K, V>

Module Contents

val EMPTY_TRIE_ROOT_HASH:

open fun getAsync(dispatcher: CoroutineDispatcher, key: K):

abstract suspend fun put(key: K, value: V?): Unit

open fun putAsync(key: K, value: V?):

open fun putAsync(dispatcher: CoroutineDispatcher, key: K, value: V?):

abstract suspend fun remove(key: K): Unit

open fun removeAsync(key: K):

open fun removeAsync(dispatcher: CoroutineDispatcher, key: K):

abstract fun rootHash():

Message(version: Int = 3, protocol:

class Message

Module Contents

headers

body

)

@JvmStatic fun readMessage(message:

)

abstract fun hash(message:

val version: Int

interface MessageHashing

Module Contents

)

interface MessageListener

Module Contents

abstract fun listen(messageBody:

abstract fun sendMessage(verb: Verb!, attributes: String!, peer:

attributes

String

)

Unit

interface MessageSender

Module Contents

hash

@Nullable

payload

interface MessageValidator

)

Unit

Module Contents

Module Contents

abstract fun validate(message:

peer

)

Boolean

interface Multiplexer

Module Contents

abstract fun makeAsyncRequest(request:

)

abstract fun openStream(request:

streamFactory

Function

Runnable

open class MutableByteBufferWrappingBytes : ByteBufferWrappingBytes,

)

Unit

Module Contents

open fun mutableSlice(i: Int, length: Int):

open fun set(i: Int, b: Byte): Unit

interface MutableBytes :

open static fun create(size: Int):

Module Contents

open fun clear(): Unit

open fun decrement():

open fun fill(b: Byte): Unit

open fun increment():

abstract fun mutableSlice(i: Int, length: Int):

abstract fun set(i: Int, b: Byte): Unit

open fun set(offset: Int, bytes:

)

Unit

open static fun wrap(value: ByteArray!, offset: Int, length: Int):

open static fun wrapBuffer(buffer: Buffer!, offset: Int, size: Int):

open static fun wrapByteBuf(byteBuf: ByteBuf!, offset: Int, size: Int):

open static fun wrapByteBuffer(byteBuffer: ByteBuffer!):

open static fun wrapByteBuffer(byteBuffer: ByteBuffer!, offset: Int, size: Int):

interface MutableBytes32 :

Module Contents

open static fun wrap(value: ByteArray!, offset: Int):

)

offset

Int

)

interface MutableBytes48 :

Module Contents

open static fun wrap(value: ByteArray!, offset: Int):

)

offset

Int

)

open class NetworkService

Module Contents

protected NetworkService(multiplexer:

open fun createChangesStream(streamHandler: Function<Runnable!,

)

open fun generateInviteCode(validForUses: Int):

PeerStateChange

)

Unit

open fun getAllKnownPeers():

MutableList

open fun getConnectedPeers():

MutableList

open fun redeemInviteCode(invite:

)

class NoConfigurationPropertyException : RuntimeException

class NodeStats

Module Contents

NodeStats(active: Boolean, syncing: Boolean, mining: Boolean, hashrate: Int, peerCount: Int, gasPrice: Int, uptime: Int)

fun getGasPrice(): Int

fun getHashrate(): Int

fun getPeerCount(): Int

fun getUptime(): Int

fun isActive(): Boolean

fun isMining(): Boolean

fun isSyncing(): Boolean

org.apache.tuweni.concurrent.AsyncCompletion

Module Contents

fun

asDeferred

(

)

Deferred

Unit

suspend fun

org.apache.tuweni.concurrent.AsyncResult

await

(

)

Unit

Module Contents

fun <T>

asDeferred

(

)

Deferred

suspend fun <T>

static fun argon2i13(): Algorithm!

await

(

)

class PasswordHash

Module Contents

PasswordHash()

class Algorithm

Module Contents

static fun argon2id13(): Algorithm!

fun isSupported(): Boolean

fun name(): String!

static fun recommended(): Algorithm!

static fun checkHash(hash: String!, password: String!): VerificationResult!

static fun checkHash(hash: String!, password: String!, opsLimit: Long, memLimit: Long): VerificationResult!

static fun checkHashForInteractive(hash: String!, password: String!): VerificationResult!

static fun checkHashForSensitive(hash: String!, password: String!): VerificationResult!

static fun hash(password: String!, length: Int, salt: Salt!):

length

Int

salt

Salt

)

static fun hash(password: ByteArray!, length: Int, salt: Salt!): ByteArray!

static fun hash(password: String!, length: Int, salt: Salt!, algorithm: Algorithm!):

length

Int

salt

Salt

algorithm

Algorithm

)

static fun hash(password: ByteArray!, length: Int, salt: Salt!, algorithm: Algorithm!): ByteArray!

static fun hash(password: String!, length: Int, salt: Salt!, opsLimit: Long, memLimit: Long, algorithm: Algorithm!):

length

Int

salt

Salt

opsLimit

Long

memLimit

Long

algorithm

Algorithm

)

static fun hash(password: ByteArray!, length: Int, salt: Salt!, opsLimit: Long, memLimit: Long, algorithm: Algorithm!): ByteArray!

static fun hash(password: String!): String!

static fun hash(password: String!, opsLimit: Long, memLimit: Long): String!

static fun hashInteractive(password: String!, length: Int, salt: Salt!):

length

Int

salt

Salt

)

static fun hashInteractive(password: ByteArray!, length: Int, salt: Salt!): ByteArray!

static fun hashInteractive(password: String!, length: Int, salt: Salt!, algorithm: Algorithm!):

length

Int

salt

Salt

algorithm

Algorithm

)

static fun hashInteractive(password: ByteArray!, length: Int, salt: Salt!, algorithm: Algorithm!): ByteArray!

static fun hashInteractive(password: String!): String!

static fun hashSensitive(password: String!, length: Int, salt: Salt!):

length

Int

salt

Salt

)

static fun hashSensitive(password: ByteArray!, length: Int, salt: Salt!): ByteArray!

static fun hashSensitive(password: String!, length: Int, salt: Salt!, algorithm: Algorithm!):

length

Int

salt

Salt

algorithm

Algorithm

)

static fun hashSensitive(password: ByteArray!, length: Int, salt: Salt!, algorithm: Algorithm!): ByteArray!

static fun hashSensitive(password: String!): String!

static fun interactiveMemLimit(): Long

static fun interactiveOpsLimit(): Long

static fun maxHashLength(): Int

static fun maxMemLimit(): Long

static fun maxOpsLimit(): Long

static fun minHashLength(): Int

static fun minMemLimit(): Long

static fun minOpsLimit(): Long

static fun moderateMemLimit(): Long

static fun moderateOpsLimit(): Long

static fun needsRehash(hash: String!): Boolean

static fun needsRehash(hash: String!, opsLimit: Long, memLimit: Long): Boolean

static fun needsRehashForInteractive(hash: String!): Boolean

static fun needsRehashForSensitive(hash: String!): Boolean

class Salt

Module Contents

static fun fromBytes(bytes: ByteArray!): Salt!

)

Salt

static fun random(): Salt!

static fun sensitiveMemLimit(): Long

static fun sensitiveOpsLimit(): Long

class VerificationResult

Module Contents

FAILED

NEEDS_REHASH

fun needsRehash(): Boolean

PASSED

fun passed(): Boolean

static fun verify(hash: String!, password: String!): Boolean

Module Contents

abstract val endpoint:

abstract val enr:

abstract fun getEndpoint(ifVerifiedOnOrAfter: Long):

abstract val lastSeen: Long?

abstract val lastVerified: Long?

abstract fun seenAt(time: Long): Unit

abstract fun updateEndpoint(endpoint:

time

Long

ifVerifiedBefore

Long

)

abstract fun updateENR(record:

abstract fun verifyEndpoint(endpoint:

time

Long

)

Unit

open fun uri(): String

time

Long

)

Boolean

Module Contents

abstract fun lastContacted(): Instant?

abstract fun lastDiscovered(): Instant?

Peer(address: String!, port: Int, key: String!, state: String!)

open class Peer

Module Contents

Peer()

open fun getAddress(): String!

open fun getState(): String!

open fun getPort(): Int

interface PeerPruning

Module Contents

abstract fun prunePeer(peer:

)

Boolean

abstract suspend fun get(host: String, port: Int, nodeId: PublicKey):

Module Contents

abstract suspend fun get(uri: URI):

open suspend fun get(uri: String):

abstract fun getAsync(uri: URI):

abstract fun getAsync(uri: String):

abstract fun addConnection(peer:

Module Contents

identity

abstract fun markConnectionInactive(peer:

)

Unit

identity

abstract fun peerDiscoveredAt(peer:

)

Unit

abstract fun randomPeer():

time

Long

)

Unit

abstract fun storeIdentity(networkInterface: String, port: Int, publicKey: PublicKey):

abstract fun storePeer(id:

lastContacted

Instant

lastDiscovered

Instant

)

abstract fun addEager(peer:

Module Contents

abstract fun considerNewPeer(peer:

)

Unit

abstract fun eagerPushPeers(): MutableCollection<

)

Unit

abstract fun lazyPushPeers(): MutableCollection<

abstract fun moveToEager(peer:

abstract fun moveToLazy(peer:

)

Unit

abstract fun peers(): MutableList<

)

Boolean

abstract fun removePeer(peer:

interface PeerRepositoryConfiguration

)

Unit

Module Contents

interface PeerRoutingTable : Set<

Module Contents

abstract fun add(node:

)

abstract fun evict(node:

abstract fun nearest(targetId: PublicKey, limit: Int): List<

)

Boolean

open class PeerStateChange

Module Contents

PeerStateChange()

PeerStateChange(type: String!, peer:

)

open fun getPeer():

open fun setPeer(peer:

open fun setType(type: String!): Unit

)

Unit

open class Profile

Module Contents

Profile()

Profile(key: String!, displayName: String!)

open fun getDisplayName(): String!

static fun createDagCache(blockNumber: Long, datasetLookup: Function<

class ProgPoW

Module Contents

ProgPoW()

)

Array

static fun progPowHash(blockNumber: Long, nonce: Long, :

dag

Array

dagLookupFunction

Function

)

interface PropertyValidator<T : Any!>

Module Contents

open static fun <T : Any!> allInList(validator:

)

open static fun anyOf(vararg values: String!):

MutableList

open static fun anyOf(values: MutableCollection<String!>!):

String

open static fun anyOf(values: MutableCollection<String!>!, comparator: Comparator<String!>!):

String

open static fun anyOfIgnoreCase(vararg values: String!):

String

open static fun anyOfIgnoreCase(values: MutableCollection<String!>!):

String

open static fun <T : Any!> combine(first:

String

second

)

open static fun <T : Any!> combine(validators: MutableList<

)

open static fun inRange(from: Long, to: Long):

open static fun isPresent():

Number

Any

open static fun isURL():

abstract fun validate(key: String!, @Nullable position:

String

@Nullable

value

)

MutableList

class ProxyKeyValueStore<K, V, E, R> :

enum class Protocol

Module Contents

val code: Byte

fun fromByte(b: Byte):

ProxyKeyValueStore(store:

Module Contents

unproxyKey

(

)

proxyKey

(

)

unproxyValue

(

)

proxyValue

(

)

coroutineContext

CoroutineContext

)

@JvmStatic fun <K, V, E, R> open(store:

unproxyKey

Function

proxyKey

Function

unproxyValue

Function

proxyValue

BiFunction

)

ProxyKeyValueStore

static fun aggregate(keys: MutableList<

Module Contents

)

)

fun toByteArray(): ByteArray!

fun makeAsyncRequest(request:

class RawRequestService

Module Contents

)

fun openStream(request:

streamFactory

Function

Runnable

class RedisKeyValueStore<K, V> :

)

Unit

RedisKeyValueStore(port: Int = 6379, address: InetAddress = InetAddress.getLoopbackAddress(), keySerializer: (K) ->

Module Contents

valueSerializer

(

)

keyDeserializer

(

)

valueDeserializer

(

RedisKeyValueStore(uri: String, keySerializer: (K) ->

)

valueSerializer

(

)

keyDeserializer

(

)

valueDeserializer

(

)

coroutineContext

CoroutineContext

)

@JvmStatic fun codec(): RedisCodec<

@JvmStatic fun open(uri: String):

@JvmStatic fun <K, V> open(uri: String, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

)

@JvmStatic fun <K, V> open(port: Int, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

)

@JvmStatic fun <K, V> open(address: InetAddress, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

)

@JvmStatic fun <K, V> open(port: Int, address: InetAddress, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

)

@Target([AnnotationTarget.VALUE_PARAMETER]) class RedisPort

Module Contents

RedisPort()

class RedisServerExtension : ParameterResolver, AfterAllCallback

Module Contents

RedisServerExtension()

fun resolveParameter(parameterContext: ParameterContext!, extensionContext: ExtensionContext!): Any!

fun supportsParameter(parameterContext: ParameterContext!, extensionContext: ExtensionContext!): Boolean

class Relayer : CoroutineScope

Module Contents

Relayer(vertx: Vertx, bind: String, to: String, interceptor: (

)

Unit

coroutineContext

CoroutineContext

)

RelayerApp(vertx: Vertx, relayer:

class RelayerApp

Module Contents

Relayer

)

Request(connectionId: String, handle:

Module Contents

data

Any

)

val connectionId: String

val data: Any

val handle:

@MustBeClosed static fun find(glob: String!): Stream<URL!>!

class Resources

Module Contents

@MustBeClosed static fun find(@Nullable classLoader: ClassLoader?, glob: String!): Stream<URL!>!

class RLP

Module Contents

Function

)

lenient

Boolean

Function

)

)

BigInteger

lenient

Boolean

)

BigInteger

)

Int

lenient

Boolean

)

Int

Function

)

lenient

Boolean

Function

)

)

Long

lenient

Boolean

)

Long

)

String

lenient

Boolean

)

String

BiConsumer

MutableList

Any

)

MutableList

Any

lenient

Boolean

BiConsumer

MutableList

Any

)

MutableList

Any

Function

)

MutableList

lenient

Boolean

Function

)

MutableList

)

lenient

Boolean

)

)

static fun encodeBigInteger(value: BigInteger!):

static fun encodeInt(value: Int):

static fun encodeList(fn: Consumer<

)

static fun <T : Any!> encodeList(elements: MutableList<T>!, fn: BiConsumer<

)

static fun <T : ByteBuffer!> encodeListTo(buffer: T, fn: Consumer<

static fun encodeLong(value: Long):

)

static fun <T : ByteBuffer!> encodeTo(buffer: T, fn: Consumer<

static fun encodeValue(value:

)

)

static fun isList(value:

open class RLPException : RuntimeException

)

Boolean

Module Contents

RLPException(message: String!)

RLPException(cause: Throwable!)

RLPException(message: String!, cause: Throwable!)

interface RLPReader

Module Contents

abstract fun isLenient(): Boolean

abstract fun nextIsEmpty(): Boolean

abstract fun nextIsList(): Boolean

abstract fun position(): Int

open fun readBigInteger(): BigInteger!

open fun readBigInteger(lenient: Boolean): BigInteger!

open fun readByte(): Byte

open fun readByte(lenient: Boolean): Byte

open fun readInt(lenient: Boolean): Int

open fun readInt(): Int

open fun <T : Any!> readList(fn: Function<

abstract fun <T : Any!> readList(lenient: Boolean, fn: Function<

)

open fun readList(fn: BiConsumer<

)

open fun readList(lenient: Boolean, fn: BiConsumer<

MutableList

Any

)

MutableList

Any

open fun <T : Any!> readListContents(fn: Function<

MutableList

Any

)

MutableList

Any

open fun <T : Any!> readListContents(lenient: Boolean, fn: Function<

)

MutableList

open fun readLong(): Long

)

MutableList

open fun readLong(lenient: Boolean): Long

open fun readString(lenient: Boolean): String!

open fun readUInt256():

open fun readUInt256(lenient: Boolean):

open fun readValue():

abstract fun readValue(lenient: Boolean):

abstract fun remaining(): Int

open fun skipNext(): Unit

abstract fun skipNext(lenient: Boolean): Unit

interface RLPWriter

Module Contents

open fun writeBigInteger(value: BigInteger!): Unit

open fun writeByte(value: Byte): Unit

open fun writeByteArray(value: ByteArray!): Unit

open fun writeInt(value: Int): Unit

abstract fun writeList(fn: Consumer<

open fun <T : Any!> writeList(elements: MutableList<T>!, elementWriter: BiConsumer<

)

Unit

abstract fun writeLong(value: Long): Unit

)

Unit

abstract fun writeRLP(value:

)

Unit

abstract fun writeValue(value:

)

Unit

fun configureAfterHandshake(helloMessage:

)

Unit

class RLPxConnection

Module Contents

)

Unit

static fun isComplementedBy(one:

other

)

Boolean

fun readFrame(messageFrame:

)

messageConsumer

Consumer

)

Unit

fun write(message:

)

class RLPxConnectionFactory

Module Contents

RLPxConnectionFactory()

static fun createConnection(initiator: Boolean, initiatorMessage:

responderMessage

ourEphemeralPrivateKey

SecretKey

peerEphemeralPublicKey

PublicKey

initiatorNonce

responderNonce

ourPublicKey

PublicKey

peerPublicKey

PublicKey

)

static fun createHandshake(keyPair: KeyPair!, remotePublicKey: PublicKey!, initAndResponse: Function<

)

static fun generateRandomBytes32():

static fun init(keyPair: KeyPair!, remotePublicKey: PublicKey!, ephemeralKeyPair: KeyPair!, initiatorNonce:

)

static fun messageSize(msgBytes:

static fun readResponse(response:

)

Int

static fun respondToHandshake(initiatorMessageBytes:

privateKey

SecretKey

)

HandshakeMessage

keyPair

KeyPair

responseHandler

Consumer

)

RLPxMessage(messageId: Int, content:

class RLPxMessage

Module Contents

)

fun content():

abstract fun actualPort(): Int

fun messageId(): Int

interface RLPxService

Module Contents

abstract fun actualSocketAddress(): InetSocketAddress!

abstract fun addToKeepAliveList(peerPublicKey: PublicKey!): Boolean

abstract fun connectTo(peerPublicKey: PublicKey!, peerAddress: InetSocketAddress!):

abstract fun disconnect(connection:

reason

abstract fun getClient(subProtocolIdentifier:

)

Unit

)

abstract fun repository():

abstract fun send(subProtocolIdentifier:

messageType

Int

connection

message

)

Unit

abstract fun start():

abstract fun stop():

interface RLPxServiceConfiguration

Module Contents

abstract fun clientName(): String

abstract fun repository(): String

class RocksDBKeyValueStore<K, V> :

RocksDBKeyValueStore(dbPath: Path, keySerializer: (K) ->

Module Contents

valueSerializer

(

)

keyDeserializer

(

)

valueDeserializer

(

)

options

Options

coroutineContext

CoroutineContext

)

@JvmStatic fun <K, V> open(dbPath: Path, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

)

@JvmStatic fun <K, V> open(dbPath: Path, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

options

Options

)

open class RPCAsyncRequest

Module Contents

RPCAsyncRequest(function:

arguments

MutableList

Any

)

open fun toEncodedRpcMessage(objectMapper: ObjectMapper!):

static fun encodeRequest(body: String!, vararg flags:

class RPCCodec

Module Contents

RPCCodec()

)

vararg

flags

)

requestNumber

Int

vararg

flags

)

requestNumber

Int

flags

Byte

)

requestNumber

Int

flagByte

Byte

)

requestNumber

Int

flagByte

Byte

vararg

flags

)

requestNumber

Int

vararg

flags

)

static fun encodeStreamEndRequest(requestNumber: Int):

RPCErrorBody(name: String!, message: String!, stack: String!)

open class RPCErrorBody

Module Contents

RPCErrorBody()

open fun getMessage(): String!

open fun getStack(): String!

open fun setMessage(message: String!): Unit

open fun setName(name: String!): Unit

open fun setStack(stack: String!): Unit

interface RPCFlag

Module Contents

open fun apply(flagsByte: Byte): Byte

class BodyType :

static fun extractBodyType(flagByte: Byte): BodyType!

Module Contents

BINARY

fun isApplied(flagByte: Byte): Boolean

Module Contents

open fun isApplied(flagsByte: Byte): Boolean

Module Contents

abstract fun value(): Int

open class RPCFunction

Module Contents

RPCFunction(namespace: MutableList<String!>!, functionName: String!)

RPCFunction(functionName: String!)

open fun asList(): MutableList<String!>!

open class RPCHandler :

RPCHandler(vertx: Vertx!, messageSender: Consumer<

Module Contents

terminationFn

Runnable

)

open fun makeAsyncRequest(request:

)

open fun openStream(request:

responseSink

Function

Runnable

open fun receivedMessage(message:

)

Unit

open fun streamClosed(): Unit

)

Unit

class RPCMessage

Module Contents

RPCMessage(messageBytes:

fun <T : Any!> asJSON(objectMapper: ObjectMapper!, clazz: Class<T>!): T

)

fun asString(): String!

fun body():

fun bodyType(): BodyType!

fun getErrorBody(objectMapper: ObjectMapper!): Optional<

RPCErrorBody

fun getException(objectMapper: ObjectMapper!): Optional<

RPCRequestFailedException

fun isErrorMessage(): Boolean

fun isSuccessfulLastMessage(): Boolean

fun lastMessageOrError(): Boolean

fun requestNumber(): Int

fun rpcFlags(): Byte

fun stream(): Boolean

open class RPCRequestBody

Module Contents

RPCRequestBody(name: MutableList<String!>!, type:

RPCRequestType

args

MutableList

Any

)

open fun asBytes(objectMapper: ObjectMapper!):

open fun getArgs(): MutableList<Any!>!

open fun getName(): MutableList<String!>!

open fun getType():

RPCRequestType

class RPCRequestFailedException : RuntimeException

Module Contents

RPCRequestFailedException(errorMessage: String!)

class RPCRequestType

Module Contents

ASYNC

SOURCE

open class RPCResponse

Module Contents

RPCResponse(body:

open fun <T : Any!> asJSON(objectMapper: ObjectMapper!, clazz: Class<T>!): T

bodyType

BodyType

)

open fun <T : Any!> asJSON(objectMapper: ObjectMapper!, typeReference: TypeReference<T>!): T

open fun asString(): String!

open fun body():

open fun bodyType(): BodyType!

open class RPCStreamRequest

Module Contents

RPCStreamRequest(function:

arguments

MutableList

Any

)

open fun toEncodedRpcMessage(mapper: ObjectMapper!):

fun defaultsKeySet(): MutableSet<String!>!

class Schema

Module Contents

fun defaultsKeySet(prefix: String!): MutableSet<String!>!

@Nullable fun description(key: String!): String?

fun getDefault(key: String!): Any!

@Nullable fun getDefaultBoolean(key: String!): Boolean?

@Nullable fun getDefaultDouble(key: String!): Double?

@Nullable fun getDefaultInteger(key: String!): Int?

@Nullable fun getDefaultList(key: String!): MutableList<Any!>?

@Nullable fun getDefaultListOfBoolean(key: String!): MutableList<Boolean!>?

@Nullable fun getDefaultListOfDouble(key: String!): MutableList<Double!>?

@Nullable fun getDefaultListOfInteger(key: String!): MutableList<Int!>?

@Nullable fun getDefaultListOfLong(key: String!): MutableList<Long!>?

@Nullable fun getDefaultListOfMap(key: String!): MutableList<MutableMap<String!, Any!>!>?

@Nullable fun getDefaultListOfString(key: String!): MutableList<String!>?

@Nullable fun getDefaultLong(key: String!): Long?

@Nullable fun getDefaultMap(key: String!): MutableMap<String!, Any!>?

@Nullable fun getDefaultString(key: String!): String?

fun getSubSection(name: String!):

fun getSubSectionPrefix(key: String!): String!

fun hasDefault(key: String!): Boolean

fun validate(configuration:

)

Stream

fun addBoolean(key: String!, @Nullable defaultValue: Boolean?, @Nullable description: String?, @Nullable validator:

class SchemaBuilder

Module Contents

Boolean

)

fun addDefault(key: String!, value: Any!):

fun addDouble(key: String!, @Nullable defaultValue: Double?, @Nullable description: String?, @Nullable validator:

Double

)

fun addInteger(key: String!, @Nullable defaultValue: Int?, @Nullable description: String?, @Nullable validator:

Int

)

fun addListOfBoolean(key: String!, @Nullable defaultValue: MutableList<Boolean!>?, @Nullable description: String?, @Nullable validator:

MutableList

Boolean

)

fun addListOfDouble(key: String!, @Nullable defaultValue: MutableList<Double!>?, @Nullable description: String?, @Nullable validator:

MutableList

Double

)

fun addListOfInteger(key: String!, @Nullable defaultValue: MutableList<Int!>?, @Nullable description: String?, @Nullable validator:

MutableList

Int

)

fun addListOfLong(key: String!, @Nullable defaultValue: MutableList<Long!>?, @Nullable description: String?, @Nullable validator:

MutableList

Long

)

fun addListOfMap(key: String!, @Nullable defaultValue: MutableList<MutableMap<String!, Any!>!>?, @Nullable description: String?, @Nullable validator:

MutableList

MutableMap

String

Any

)

fun addListOfString(key: String!, @Nullable defaultValue: MutableList<String!>?, @Nullable description: String?, @Nullable validator:

MutableList

String

)

fun addLong(key: String!, @Nullable defaultValue: Long?, @Nullable description: String?, @Nullable validator:

Long

)

fun addSection(key: String!, section:

)

fun addString(key: String!, @Nullable defaultValue: String?, @Nullable description: String?, @Nullable validator:

String

)

static fun create():

fun documentProperty(key: String!, description: String!):

fun toSchema():

fun validateConfiguration(validator:

ConfigurationValidator

)

fun validateProperty(key: String!, validator:

Any

)

Scraper(coroutineContext: CoroutineContext = Executors.newFixedThreadPool(100).asCoroutineDispatcher(), vertx: Vertx = Vertx.vertx(), initialURIs: List<URI>, bindAddress: SocketAddress, listeners: List<(

Module Contents

List

val bindAddress: SocketAddress

)

Unit

maxWaitForNewPeers

Long

waitBetweenScrapes

Long

)

fun discover(maxWaitForNewPeers: Long): Deferred<Unit>

val initialURIs: List<URI>

List

)

Unit

Scraper(coroutineContext: CoroutineContext = Executors.newFixedThreadPool(100).asCoroutineDispatcher(), vertx: Vertx = Vertx.vertx(), initialENRs: List<

Module Contents

bindAddress

InetSocketAddress

listeners

List

(

List

val bindAddress: InetSocketAddress

)

Unit

maxWaitForNewPeers

Long

waitBetweenScrapes

Long

)

fun discover(maxWaitForNewPeers: Long): Deferred<Unit>

val initialENRs: List<

List

)

Unit

Module Contents

Module Contents

open class ScuttlebuttClient

Module Contents

protected ScuttlebuttClient(multiplexer:

open fun getFeedService():

)

open fun getNetworkService():

NetworkService

open fun getSocialService():

SocialService

open fun rawRequestService():

RawRequestService

class ScuttlebuttClientFactory

Module Contents

static val DEFAULT_NETWORK:

static fun fromNet(host: String!, port: Int, keyPair: KeyPair!, serverPublicKey: PublicKey!):

static fun fromNetWithNetworkKey(vertx: Vertx!, host: String!, port: Int, keyPair: KeyPair!, serverPublicKey: PublicKey!, networkIdentifier:

)

static fun fromNetWithVertx(vertx: Vertx!, host: String!, port: Int, keyPair: KeyPair!, serverPublicKey: PublicKey!):

static fun withInvite(vertx: Vertx!, keyPair: KeyPair!, invite:

networkIdentifier

)

open class ScuttlebuttLocalDiscoveryService

Module Contents

ScuttlebuttLocalDiscoveryService(vertx: Vertx!, listenPort: Int, listenNetworkInterface: String!, multicastAddress: String!)

open fun addIdentityToBroadcastList(identity:

open fun addListener(listener: Consumer<

)

Unit

interface ScuttlebuttMessageContent

)

Unit

Module Contents

abstract fun getType(): String!

interface ScuttlebuttStreamHandler

Module Contents

abstract fun onMessage(message:

)

Unit

static fun calculateKeyAgreement(privKey: SecretKey!, theirPubKey: PublicKey!):

class SECP256K1

Module Contents

static fun deriveECDHKeyAgreement(srcPrivKey:

destPubKey

)

Module Contents

open static fun create(secretKey: SecretKey!, publicKey: PublicKey!): KeyPair!

open static fun fromSecretKey(secretKey: SecretKey!): KeyPair!

open static fun load(file: Path!): KeyPair!

open fun publicKey(): PublicKey!

open static fun random(): KeyPair!

open fun secretKey(): SecretKey!

static val CURVE: ECDomainParameters!

class Parameters

Module Contents

Parameters()

open fun asEcPoint(): ECPoint!

Module Contents

open static fun fromHexString(str: CharSequence!): PublicKey!

)

PublicKey

open static fun fromInteger(privateKey: BigInteger!): PublicKey!

open static fun fromSecretKey(secretKey: SecretKey!): PublicKey!

@Nullable open static fun recoverFromHashAndSignature(hash: ByteArray!, signature: Signature!): PublicKey?

@Nullable open static fun recoverFromHashAndSignature(hash:

@Nullable open static fun recoverFromSignature(data: ByteArray!, signature: Signature!): PublicKey?

signature

Signature

)

PublicKey

@Nullable open static fun recoverFromSignature(data:

signature

Signature

)

PublicKey

Module Contents

open fun destroy(): Unit

protected open fun finalize(): Unit

open static fun fromInteger(key: BigInteger!): SecretKey!

)

SecretKey

open static fun load(file: Path!): SecretKey!

static fun sign(data: ByteArray!, keyPair: KeyPair!): Signature!

static fun sign(data:

keyPair

KeyPair

)

Signature

Module Contents

open static fun create(v: Byte, r: BigInteger!, s: BigInteger!): Signature!

)

Signature

open fun isCanonical(): Boolean

open fun r(): BigInteger!

open fun s(): BigInteger!

static fun signHashed(hash: ByteArray!, keyPair: KeyPair!): Signature!

open fun v(): Byte

static fun signHashed(hash:

static fun verify(data: ByteArray!, signature: Signature!, publicKey: PublicKey!): Boolean

keyPair

KeyPair

)

Signature

static fun verify(data:

static fun verifyHashed(hash:

signature

Signature

publicKey

PublicKey

)

Boolean

static fun verifyHashed(hash: ByteArray!, signature: Signature!, publicKey: PublicKey!): Boolean

signature

Signature

publicKey

PublicKey

)

Boolean

class SecretBox

Module Contents

key

Key

nonce

Nonce

)

key

Key

nonce

Nonce

)

@Nullable static fun decrypt(cipherText: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

password

String

)

@Nullable static fun decrypt(cipherText: ByteArray!, password: String!): ByteArray?

password

String

algorithm

Algorithm

)

@Nullable static fun decrypt(cipherText: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray?

password

String

opsLimit

Long

memLimit

Long

algorithm

Algorithm

)

@Nullable static fun decrypt(cipherText: ByteArray!, password: String!, opsLimit: Long, memLimit: Long, algorithm: Algorithm!): ByteArray?

mac

key

Key

nonce

Nonce

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

mac

password

String

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, password: String!): ByteArray?

mac

password

String

algorithm

Algorithm

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray?

mac

password

String

opsLimit

Long

memLimit

Long

algorithm

Algorithm

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, password: String!, opsLimit: Long, memLimit: Long, algorithm: Algorithm!): ByteArray?

@Nullable static fun decryptInteractive(cipherText:

password

String

)

@Nullable static fun decryptInteractive(cipherText: ByteArray!, password: String!): ByteArray?

@Nullable static fun decryptInteractive(cipherText:

password

String

algorithm

Algorithm

)

@Nullable static fun decryptInteractive(cipherText: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray?

@Nullable static fun decryptInteractiveDetached(cipherText:

mac

password

String

)

@Nullable static fun decryptInteractiveDetached(cipherText: ByteArray!, mac: ByteArray!, password: String!): ByteArray?

@Nullable static fun decryptInteractiveDetached(cipherText:

mac

password

String

algorithm

Algorithm

)

@Nullable static fun decryptInteractiveDetached(cipherText: ByteArray!, mac: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray?

password

String

)

@Nullable static fun decryptSensitive(cipherText: ByteArray!, password: String!): ByteArray?

password

String

algorithm

Algorithm

)

@Nullable static fun decryptSensitive(cipherText: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray?

@Nullable static fun decryptSensitiveDetached(cipherText:

mac

password

String

)

@Nullable static fun decryptSensitiveDetached(cipherText: ByteArray!, mac: ByteArray!, password: String!): ByteArray?

@Nullable static fun decryptSensitiveDetached(cipherText:

mac

password

String

algorithm

Algorithm

)

@Nullable static fun decryptSensitiveDetached(cipherText: ByteArray!, mac: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray?

key

Key

nonce

Nonce

)

key

Key

nonce

Nonce

)

static fun encrypt(message: ByteArray!, key: Key!, nonce: Nonce!): ByteArray!

password

String

)

static fun encrypt(message: ByteArray!, password: String!): ByteArray!

password

String

algorithm

Algorithm

)

static fun encrypt(message: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray!

password

String

opsLimit

Long

memLimit

Long

algorithm

Algorithm

)

static fun encrypt(message: ByteArray!, password: String!, opsLimit: Long, memLimit: Long, algorithm: Algorithm!): ByteArray!

key

Key

nonce

Nonce

)

static fun encryptDetached(message: ByteArray!, key: Key!, nonce: Nonce!):

password

String

)

static fun encryptDetached(message: ByteArray!, password: String!):

password

String

algorithm

Algorithm

)

static fun encryptDetached(message: ByteArray!, password: String!, algorithm: Algorithm!):

password

String

opsLimit

Long

memLimit

Long

algorithm

Algorithm

)

static fun encryptDetached(message: ByteArray!, password: String!, opsLimit: Long, memLimit: Long, algorithm: Algorithm!):

password

String

)

static fun encryptInteractive(message: ByteArray!, password: String!): ByteArray!

password

String

algorithm

Algorithm

)

static fun encryptInteractive(message: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray!

password

String

)

static fun encryptInteractiveDetached(message: ByteArray!, password: String!):

password

String

algorithm

Algorithm

)

static fun encryptInteractiveDetached(message: ByteArray!, password: String!, algorithm: Algorithm!):

password

String

)

static fun encryptSensitive(message: ByteArray!, password: String!): ByteArray!

password

String

algorithm

Algorithm

)

static fun encryptSensitive(message: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray!

password

String

)

static fun encryptSensitiveDetached(message: ByteArray!, password: String!):

password

String

algorithm

Algorithm

)

static fun encryptSensitiveDetached(message: ByteArray!, password: String!, algorithm: Algorithm!):

Module Contents

)

Key

class Nonce : Destroyable

Module Contents

)

Nonce

interface SecretDecryptionStream : Destroyable

Module Contents

open fun pull(cipherText:

)

abstract fun pull(cipherText: ByteArray!): ByteArray!

interface SecretEncryptionStream : Destroyable

Module Contents

open fun header():

abstract fun headerArray(): ByteArray!

)

open fun push(clearText: ByteArray!): ByteArray!

isFinal

Boolean

)

abstract fun push(clearText: ByteArray!, isFinal: Boolean): ByteArray!

open fun pushLast(clearText:

)

open fun pushLast(clearText: ByteArray!): ByteArray!

class SecretKey

Module Contents

SecretKey

class SecureScuttlebuttHandshakeClient

)

Module Contents

static fun create(ourKeyPair: KeyPair!, networkIdentifier:

serverLongTermPublicKey

PublicKey

)

fun createHello():

fun createIdentityMessage():

SecureScuttlebuttStreamClient

fun createStream():

static fun fromInvite(networkIdentifier:

invite

)

fun readAcceptMessage(message:

)

Unit

class SecureScuttlebuttHandshakeServer

)

Unit

Module Contents

static fun create(ourKeyPair: KeyPair!, networkIdentifier:

SecureScuttlebuttHandshakeServer

)

fun createAcceptMessage():

SecureScuttlebuttStreamServer

fun readIdentityMessage(message:

)

Unit

interface SecureScuttlebuttStreamClient

)

Unit

Module Contents

abstract fun readFromServer(message:

)

abstract fun sendGoodbyeToServer():

abstract fun sendToServer(message:

)

interface SecureScuttlebuttStreamServer

Module Contents

open static fun isGoodbye(message:

abstract fun readFromClient(message:

)

Boolean

)

abstract fun sendGoodbyeToClient():

abstract fun sendToClient(message:

)

class SecureScuttlebuttVertxClient

Module Contents

SecureScuttlebuttVertxClient(vertx: Vertx!, keyPair: KeyPair!, networkIdentifier:

)

class SecureScuttlebuttVertxServer

connectTo

(

port

Int

host

String

@Nullable

remotePublicKey

PublicKey

@Nullable

invite

handlerFactory

)

Module Contents

SecureScuttlebuttVertxServer(vertx: Vertx!, addr: InetSocketAddress!, keyPair: KeyPair!, networkIdentifier:

handlerFactory

)

interface ServerHandler

Module Contents

)

Unit

interface ServerHandlerFactory

Module Contents

terminationFunction

Runnable

)

ServerHandler

open class SHA256Hash

Module Contents

SHA256Hash()

Module Contents

open static fun hash(input: Input!): Hash!

Module Contents

)

Input

static fun fromSecret(secret: Secret!): Input!

)

Input

static fun aggregate(signatures: MutableList<

Module Contents

)

fun combine(signature:

)

static fun decode(bytes:

)

Module Contents

KeyPair(publicKey: PublicKey!, secretKey: SecretKey!)

Module Contents

static fun forSecretKey(secretKey: SecretKey!): KeyPair!

Module Contents

static fun fromBytes(bytes: ByteArray!): PublicKey!

)

PublicKey

signature

)

Boolean

signature

)

Boolean

Module Contents

static fun fromBytes(bytes: ByteArray!): SecretKey!

)

SecretKey

static fun fromSeed(seed: Seed!): SecretKey!

Module Contents

)

Seed

static fun sign(message:

secretKey

SecretKey

)

static fun sign(message: ByteArray!, secretKey: SecretKey!): ByteArray!

secretKey

SecretKey

)

secretKey

SecretKey

)

static fun signDetached(message: ByteArray!, secretKey: SecretKey!): ByteArray!

static fun verify(signed:

publicKey

PublicKey

)

static fun verify(signed: ByteArray!, publicKey: PublicKey!): ByteArray!

signature

publicKey

PublicKey

)

Boolean

signature

static fun verifyDetached(message: ByteArray!, signature: ByteArray!, publicKey: PublicKey!): Boolean

publicKey

PublicKey

)

Boolean

class SignatureAndPublicKey

Module Contents

static fun aggregate(sigAndPubKeys: MutableList<

)

fun combine(sigAndPubKey:

)

data class SimpleBlockchainInformation :

SimpleBlockchainInformation(networkID:

Module Contents

totalDifficulty

bestHash

bestNumber

genesisHash

forks

List

Long

)

fun forks(): List<Long>

val forks: List<Long>

fun totalDifficulty():

val totalDifficulty:

protected SocialService(multiplexer:

open class SocialService

Module Contents

feedService

open fun getFollowedBy():

)

MutableList

open fun getFollowing():

MutableList

open fun getFriends():

MutableList

open fun getOwnIdentity():

open fun getOwnProfile():

String

open fun getProfile(publicKey: String!):

open fun setDisplayName(displayName: String!):

class Sodium

Module Contents

static fun loadLibrary(path: Path!): Unit

static fun minSupportedVersion():

static fun searchLibrary(vararg paths: Path!): Unit

static fun searchLibrary(libraryName: String!, vararg paths: Path!): Unit

static fun supportsVersion(requiredVersion:

)

Boolean

static fun version():

class SodiumException : RuntimeException

Module Contents

SodiumException(message: String!)

class SodiumVersion : Comparable<

Module Contents

fun compareTo(other:

)

Int

fun major(): Int

fun minor(): Int

class SQLKeyValueStore<K, V> :

SQLKeyValueStore(jdbcurl: String, tableName: String = "store", keyColumn: String = "key", valueColumn: String = "value", keySerializer: (K) ->

Module Contents

valueSerializer

(

)

keyDeserializer

(

)

valueDeserializer

(

)

coroutineContext

CoroutineContext

)

val keyColumn: String

@JvmStatic fun <K, V> open(jdbcUrl: String, keySerializer: (K) ->

valueSerializer

(

)

keyDeserializer

(

)

valueDeserializer

(

)

@JvmStatic fun <K, V> open(jdbcUrl: String, tableName: String, keyColumn: String, valueColumn: String, keySerializer: (K) ->

valueSerializer

(

)

keyDeserializer

(

)

valueDeserializer

(

)

val tableName: String

val valueColumn: String

class SSZ

Module Contents

static fun decodeAddress(source:

Function

SSZReader

)

)

static fun decodeAddressList(source:

)

MutableList

static fun decodeBigIntegerList(source:

bitLength

Int

)

BigInteger

static fun decodeBoolean(source:

bitLength

Int

)

MutableList

BigInteger

static fun decodeBooleanList(source:

)

Boolean

)

MutableList

Boolean

)

MutableList

ByteArray

limit

Int

)

MutableList

ByteArray

)

limit

Int

)

)

MutableList

limit

Int

)

MutableList

static fun decodeHash(source:

hashLength

Int

)

static fun decodeHashList(source:

hashLength

Int

)

MutableList

static fun decodeInt16(source:

bitLength

Int

)

Int

static fun decodeInt16List(source:

)

Int

static fun decodeInt32(source:

)

MutableList

Int

static fun decodeInt32List(source:

)

Int

static fun decodeInt64(source:

)

MutableList

Int

static fun decodeInt64List(source:

)

Long

static fun decodeInt8(source:

)

MutableList

Long

static fun decodeInt8List(source:

)

Int

static fun decodeIntList(source:

)

MutableList

Int

bitLength

Int

)

MutableList

Int

static fun decodeLongIntList(source:

bitLength

Int

)

Long

bitLength

Int

)

MutableList

Long

)

String

limit

Int

)

String

)

MutableList

String

static fun decodeUInt(source:

limit

Int

)

MutableList

String

static fun decodeUInt16(source:

bitLength

Int

)

Int

static fun decodeUInt16List(source:

)

Int

static fun decodeUInt256(source:

)

MutableList

Int

)

static fun decodeUInt256List(source:

)

MutableList

static fun decodeUInt32(source:

static fun decodeUInt32List(source:

)

Long

static fun decodeUInt384(source:

)

MutableList

Long

)

static fun decodeUInt384List(source:

)

MutableList

static fun decodeUInt64(source:

static fun decodeUInt64List(source:

)

Long

static fun decodeUInt8(source:

)

MutableList

Long

static fun decodeUInt8List(source:

)

Int

static fun decodeUIntList(source:

)

MutableList

Int

static fun decodeULong(source:

bitLength

Int

)

MutableList

Int

static fun decodeULongIntList(source:

bitLength

Int

)

Long

static fun decodeUnsignedBigInteger(source:

bitLength

Int

)

MutableList

Long

static fun decodeUnsignedBigIntegerList(source:

bitLength

Int

)

BigInteger

bitLength

Int

)

MutableList

BigInteger

)

static fun encodeAddress(address:

)

static fun encodeAddressList(vararg elements:

)

static fun encodeAddressList(elements: MutableList<out

)

static fun encodeBigInteger(value: BigInteger!, bitLength: Int):

static fun encodeBigIntegerList(bitLength: Int, vararg elements: BigInteger!):

static fun encodeBigIntegerList(bitLength: Int, elements: MutableList<BigInteger!>!):

static fun encodeBigIntegerToByteArray(value: BigInteger!, bitLength: Int): ByteArray!

static fun encodeBoolean(value: Boolean):

static fun encodeBooleanList(vararg elements: Boolean):

static fun encodeBooleanList(elements: MutableList<Boolean!>!):

static fun encodeBytes(value:

)

static fun encodeBytesList(vararg elements:

)

static fun encodeBytesList(elements: MutableList<out

)

static fun encodeHash(hash:

)

static fun encodeHashList(vararg elements:

)

static fun encodeHashList(elements: MutableList<out

)

static fun encodeInt(value: Int, bitLength: Int):

static fun encodeInt16(value: Int):

static fun encodeInt16List(vararg elements: Int):

static fun encodeInt16List(elements: MutableList<Int!>!):

static fun encodeInt32(value: Int):

static fun encodeInt32List(vararg elements: Int):

static fun encodeInt32List(elements: MutableList<Int!>!):

static fun encodeInt64(value: Long):

static fun encodeInt64List(vararg elements: Long):

static fun encodeInt64List(elements: MutableList<Long!>!):

static fun encodeInt8(value: Int):

static fun encodeInt8List(vararg elements: Int):

static fun encodeInt8List(elements: MutableList<Int!>!):

static fun encodeIntList(bitLength: Int, vararg elements: Int):

static fun encodeIntList(bitLength: Int, elements: MutableList<Int!>!):

static fun encodeLong(value: Long, bitLength: Int):

static fun encodeLongIntList(bitLength: Int, vararg elements: Long):

static fun encodeLongIntList(bitLength: Int, elements: MutableList<Long!>!):

static fun encodeStringList(vararg elements: String!):

static fun encodeStringList(elements: MutableList<String!>!):

static fun <T : ByteBuffer!> encodeTo(buffer: T, fn: Consumer<

static fun encodeUBigInteger(value: BigInteger!, bitLength: Int):

)

static fun encodeUBigIntegerToByteArray(value: BigInteger!, bitLength: Int): ByteArray!

static fun encodeUInt(value: Int, bitLength: Int):

static fun encodeUInt16(value: Int):

static fun encodeUInt16List(vararg elements: Int):

static fun encodeUInt16List(elements: MutableList<Int!>!):

static fun encodeUInt256(value:

)

static fun encodeUInt256List(vararg elements:

)

static fun encodeUInt256List(elements: MutableList<

)

static fun encodeUInt32(value: Long):

static fun encodeUInt32List(vararg elements: Long):

static fun encodeUInt32List(elements: MutableList<Long!>!):

static fun encodeUInt384(value:

)

static fun encodeUInt384List(vararg elements:

)

static fun encodeUInt384List(elements: MutableList<

)

static fun encodeUInt64(value: Long):

static fun encodeUInt64List(vararg elements: Long):

static fun encodeUInt64List(elements: MutableList<Long!>!):

static fun encodeUInt8(value: Int):

static fun encodeUInt8List(vararg elements: Int):

static fun encodeUInt8List(elements: MutableList<Int!>!):

static fun encodeUIntList(bitLength: Int, vararg elements: Int):

static fun encodeUIntList(bitLength: Int, elements: MutableList<Int!>!):

static fun encodeULong(value: Long, bitLength: Int):

static fun encodeULongIntList(bitLength: Int, vararg elements: Long):

static fun encodeULongIntList(bitLength: Int, elements: MutableList<Long!>!):

static fun hashTreeRoot(vararg bytes:

)

open class SSZException : RuntimeException

Module Contents

SSZException(message: String!)

SSZException(cause: Throwable!)

SSZException(message: String!, cause: Throwable!)

interface SSZReader

Module Contents

abstract fun readAddress():

abstract fun readAddressList(): MutableList<

abstract fun readBigInteger(bitLength: Int): BigInteger!

abstract fun readBigIntegerList(bitLength: Int): MutableList<BigInteger!>!

open fun readBoolean(): Boolean

abstract fun readBooleanList(): MutableList<Boolean!>!

open fun readByteArray(limit: Int): ByteArray!

open fun readByteArrayList(): MutableList<ByteArray!>!

open fun readByteArrayList(limit: Int): MutableList<ByteArray!>!

open fun readBytes():

abstract fun readBytes(limit: Int):

open fun readBytesList(): MutableList<

abstract fun readBytesList(limit: Int): MutableList<

open fun readFixedByteArray(byteLength: Int, limit: Int): ByteArray!

open fun readFixedBytes(byteLength: Int):

abstract fun readFixedBytes(byteLength: Int, limit: Int):

abstract fun readFixedBytesList(byteLength: Int, limit: Int): MutableList<

open fun readFixedBytesList(byteLength: Int): MutableList<

abstract fun readFixedBytesVector(listSize: Int, byteLength: Int, limit: Int): MutableList<

open fun readFixedBytesVector(listSize: Int, byteLength: Int): MutableList<

abstract fun readHash(hashLength: Int):

abstract fun readHashList(hashLength: Int): MutableList<

abstract fun readInt(bitLength: Int): Int

open fun readInt16(): Int

open fun readInt16List(): MutableList<Int!>!

open fun readInt32(): Int

open fun readInt32List(): MutableList<Int!>!

open fun readInt64(): Long

open fun readInt64List(): MutableList<Long!>!

open fun readInt8(): Int

open fun readInt8List(): MutableList<Int!>!

abstract fun readIntList(bitLength: Int): MutableList<Int!>!

abstract fun readLong(bitLength: Int): Long

abstract fun readLongIntList(bitLength: Int): MutableList<Long!>!

open fun readString(limit: Int): String!

open fun readStringList(): MutableList<String!>!

abstract fun readStringList(limit: Int): MutableList<String!>!

open fun readUInt(bitLength: Int): Int

open fun readUInt16(): Int

open fun readUInt16List(): MutableList<Int!>!

abstract fun readUInt256():

abstract fun readUInt256List(): MutableList<

open fun readUInt32(): Long

open fun readUInt32List(): MutableList<Long!>!

abstract fun readUInt384():

abstract fun readUInt384List(): MutableList<

open fun readUInt64(): Long

open fun readUInt64List(): MutableList<Long!>!

open fun readUInt8(): Int

open fun readUInt8List(): MutableList<Int!>!

open fun readUIntList(bitLength: Int): MutableList<Int!>!

open fun readULong(bitLength: Int): Long

open fun readULongIntList(bitLength: Int): MutableList<Long!>!

abstract fun readUnsignedBigInteger(bitLength: Int): BigInteger!

abstract fun readUnsignedBigIntegerList(bitLength: Int): MutableList<BigInteger!>!

open fun readVector(listSize: Long): MutableList<

abstract fun readVector(listSize: Long, limit: Int): MutableList<

open fun writeAddress(address:

interface SSZWriter

Module Contents

open fun writeAddressList(vararg elements:

)

Unit

open fun writeAddressList(elements: MutableList<out

)

Unit

open fun writeBigInteger(value: BigInteger!, bitLength: Int): Unit

)

Unit

open fun writeBigIntegerList(bitLength: Int, vararg elements: BigInteger!): Unit

open fun writeBigIntegerList(bitLength: Int, elements: MutableList<BigInteger!>!): Unit

open fun writeBoolean(value: Boolean): Unit

open fun writeBooleanList(vararg elements: Boolean): Unit

open fun writeBooleanList(elements: MutableList<Boolean!>!): Unit

open fun writeBytes(value:

open fun writeBytes(value: ByteArray!): Unit

)

Unit

open fun writeBytesList(vararg elements:

open fun writeBytesList(elements: MutableList<out

)

Unit

open fun writeFixedBytes(value:

)

Unit

open fun writeFixedBytesList(elements: MutableList<out

)

Unit

open fun writeFixedBytesVector(elements: MutableList<out

)

Unit

)

Unit

open fun writeHash(hash:

open fun writeHashList(vararg elements:

)

Unit

open fun writeHashList(elements: MutableList<out

)

Unit

open fun writeInt(value: Int, bitLength: Int): Unit

)

Unit

open fun writeInt16(value: Int): Unit

open fun writeInt16List(vararg elements: Int): Unit

open fun writeInt16List(elements: MutableList<Int!>!): Unit

open fun writeInt32(value: Int): Unit

open fun writeInt32List(vararg elements: Int): Unit

open fun writeInt32List(elements: MutableList<Int!>!): Unit

open fun writeInt64(value: Long): Unit

open fun writeInt64List(vararg elements: Long): Unit

open fun writeInt64List(elements: MutableList<Long!>!): Unit

open fun writeInt8(value: Int): Unit

open fun writeInt8List(vararg elements: Int): Unit

open fun writeInt8List(elements: MutableList<Int!>!): Unit

open fun writeIntList(bitLength: Int, vararg elements: Int): Unit

open fun writeIntList(bitLength: Int, elements: MutableList<Int!>!): Unit

open fun writeLong(value: Long, bitLength: Int): Unit

open fun writeLongIntList(bitLength: Int, vararg elements: Long): Unit

open fun writeLongIntList(bitLength: Int, elements: MutableList<Long!>!): Unit

abstract fun writeSSZ(value:

open fun writeSSZ(value: ByteArray!): Unit

)

Unit

open fun writeStringList(vararg elements: String!): Unit

open fun writeStringList(elements: MutableList<String!>!): Unit

open fun writeUBigInteger(value: BigInteger!, bitLength: Int): Unit

open fun writeUInt(value: Int, bitLength: Int): Unit

open fun writeUInt16(value: Int): Unit

open fun writeUInt16List(vararg elements: Int): Unit

open fun writeUInt16List(elements: MutableList<Int!>!): Unit

open fun writeUInt256List(vararg elements:

)

Unit

open fun writeUInt256List(elements: MutableList<

)

Unit

open fun writeUInt32(value: Long): Unit

)

Unit

open fun writeUInt32List(vararg elements: Long): Unit

open fun writeUInt32List(elements: MutableList<Long!>!): Unit

open fun writeUInt384(value:

open fun writeUInt384List(elements: MutableList<

)

Unit

open fun writeUInt384List(vararg elements:

)

Unit

open fun writeUInt64(value: Long): Unit

)

Unit

open fun writeUInt64List(vararg elements: Long): Unit

open fun writeUInt64List(elements: MutableList<Long!>!): Unit

open fun writeUInt8(value: Int): Unit

open fun writeUInt8List(vararg elements: Int): Unit

open fun writeUInt8List(elements: MutableList<Int!>!): Unit

open fun writeUIntList(bitLength: Int, vararg elements: Int): Unit

open fun writeUIntList(bitLength: Int, elements: MutableList<Int!>!): Unit

open fun writeULong(value: Long, bitLength: Int): Unit

open fun writeULongIntList(bitLength: Int, vararg elements: Long): Unit

open fun writeULongIntList(bitLength: Int, elements: MutableList<Long!>!): Unit

open fun writeVector(elements: MutableList<out

)

Unit

class State

Module Contents

messageHashingFunction

messageSender

messageListener

messageValidator

peerPruningFunction

)

messageHashingFunction

messageSender

messageListener

messageValidator

peerPruningFunction

graftDelay

Long

lazyQueueInterval

Long

)

fun addPeer(peer:

fun receiveGossipMessage(peer:

)

Unit

attributes

String

message

messageHash

fun receiveGraftMessage(peer:

)

Unit

messageHash

fun receiveIHaveMessage(peer:

)

Unit

messageHash

fun receivePruneMessage(peer:

)

Unit

)

Unit

fun sendGossipMessage(attributes: String!, message:

)

Unit

)

Module Contents

Status(protocolVersion: Int, networkID:

totalDifficulty

bestHash

genesisHash

forkHash

forkBlock

Long

)

val protocolVersion: Int

val totalDifficulty:

class StoredMerklePatriciaTrie<V> :

Module Contents

valueSerializer

(

)

valueDeserializer

(

)

rootHash

valueSerializer

(

)

valueDeserializer

(

)

fun clearCache(): Unit

valueSerializer

Function

valueDeserializer

Function

)

rootHash

valueSerializer

Function

valueDeserializer

Function

)

)

value

)

Unit

)

Unit

fun rootHash():

)

rootHash

)

)

String

rootHash

)

String

class StreamException : RuntimeException

interface StreamHandler<T : Any!>

Module Contents

abstract fun onMessage(item: T): Unit

static fun <T : Any!> enumerationStream(enumeration: Enumeration<T>!): Stream<T>!

class Streams

Module Contents

interface SubProtocol

Module Contents

abstract fun createClient(service:

)

abstract fun createHandler(service:

client

)

open fun getCapabilities(): MutableList<

abstract fun versionRange(version: Int): Int

)

Boolean

interface SubProtocolClient

interface SubProtocolHandler

Module Contents

abstract fun handle(connection:

messageType

Int

message

)

abstract fun handleNewPeerConnection(connection:

)

interface SubProtocolIdentifier

Module Contents

abstract fun name(): String!

open static fun of(name: String!, version: Int):

abstract fun version(): Int

@Target([AnnotationTarget.VALUE_PARAMETER]) class TempDirectory

Module Contents

TempDirectory()

class TempDirectoryExtension : ParameterResolver, AfterAllCallback

Module Contents

TempDirectoryExtension()

fun resolveParameter(parameterContext: ParameterContext!, extensionContext: ExtensionContext!): Any!

fun supportsParameter(parameterContext: ParameterContext!, extensionContext: ExtensionContext!): Boolean

class TLS

Module Contents

static fun certificateFingerprint(certificate: Path!): ByteArray!

static fun certificateFingerprint(certificate: Certificate!): ByteArray!

static fun certificateHexFingerprint(certificate: Path!): String!

static fun certificateHexFingerprint(certificate: Certificate!): String!

static fun createSelfSignedCertificateIfMissing(key: Path!, certificate: Path!): Boolean

static fun createSelfSignedCertificateIfMissing(key: Path!, certificate: Path!, commonName: String!): Boolean

static fun readPemFile(certificate: Path!): ByteArray!

class Toml

Module Contents

static fun canonicalDottedKey(dottedKey: String!): String!

static fun joinKeyPath(path: MutableList<String!>!): String!

static fun parse(input: String!):

static fun parse(input: String!, version:

)

static fun parse(file: Path!):

static fun parse(file: Path!, version:

)

static fun parse(is: InputStream!):

static fun parse(is: InputStream!, version:

)

static fun parse(reader: Reader!):

static fun parse(reader: Reader!, version:

)

static fun parse(channel: ReadableByteChannel!):

static fun parse(channel: ReadableByteChannel!, version:

)

static fun parseDottedKey(dottedKey: String!): MutableList<String!>!

static fun tomlEscape(text: String!): StringBuilder!

interface TomlArray

Module Contents

abstract fun containsArrays(): Boolean

abstract fun containsBooleans(): Boolean

abstract fun containsDoubles(): Boolean

abstract fun containsLocalDates(): Boolean

abstract fun containsLocalDateTimes(): Boolean

abstract fun containsLocalTimes(): Boolean

abstract fun containsLongs(): Boolean

abstract fun containsOffsetDateTimes(): Boolean

abstract fun containsStrings(): Boolean

abstract fun containsTables(): Boolean

abstract fun get(index: Int): Any!

open fun getArray(index: Int):

open fun getBoolean(index: Int): Boolean

open fun getDouble(index: Int): Double

open fun getLocalDate(index: Int): LocalDate!

open fun getLocalDateTime(index: Int): LocalDateTime!

open fun getLocalTime(index: Int): LocalTime!

open fun getLong(index: Int): Long

open fun getOffsetDateTime(index: Int): OffsetDateTime!

open fun getString(index: Int): String!

open fun getTable(index: Int):

abstract fun inputPositionOf(index: Int):

abstract fun toList(): MutableList<Any!>!

open class TomlInvalidTypeException : RuntimeException

open class TomlLexer : Lexer

Module Contents

TomlLexer(input: CharStream!)

protected static val _sharedContextCache: PredictionContextCache!

open fun action(_localctx: RuleContext!, ruleIndex: Int, actionIndex: Int): Unit

static val BasicStringMode: Int

static var channelNames: Array<String!>!

static val COMMENTS: Int

static val DateMode: Int

open fun getChannelNames(): Array<String!>!

open fun getModeNames(): Array<String!>!

static val InlineTableMode: Int

static val LiteralStringMode: Int

static val KeyMode: Int

static val MLBasicStringMode: Int

static val MLLiteralStringMode: Int

static var modeNames: Array<String!>!

open fun sempred(_localctx: RuleContext!, ruleIndex: Int, predIndex: Int): Boolean

static val ValueMode: Int

static val WHITESPACE: Int

class TomlParseError : RuntimeException

Module Contents

fun position():

open class TomlParser : Parser

Module Contents

TomlParser(input: TokenStream!)

protected static val _sharedContextCache: PredictionContextCache!

fun array(): ArrayContext!

open class ArrayContext : ParserRuleContext

Module Contents

ArrayContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun ArrayEnd(): TerminalNode!

open fun ArrayStart(): TerminalNode!

open fun arrayValues(): ArrayValuesContext!

open fun Comma(): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun arrayTable(): ArrayTableContext!

open class ArrayTableContext : ParserRuleContext

Module Contents

ArrayTableContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun ArrayTableKeyEnd(): TerminalNode!

open fun ArrayTableKeyStart(): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun arrayValue(): ArrayValueContext!

open class ArrayValueContext : ParserRuleContext

Module Contents

ArrayValueContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun arrayValues(): ArrayValuesContext!

open class ArrayValuesContext : ParserRuleContext

Module Contents

ArrayValuesContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun arrayValue(): MutableList<ArrayValueContext!>!

open fun arrayValue(i: Int): ArrayValueContext!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun basicChar(): BasicCharContext!

open class BasicCharContext : ParserRuleContext

Module Contents

BasicCharContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun basicUnescaped(): BasicUnescapedContext!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun basicString(): BasicStringContext!

open class BasicStringContext : ParserRuleContext

Module Contents

BasicStringContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun basicChar(): MutableList<BasicCharContext!>!

open fun basicChar(i: Int): BasicCharContext!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun QuotationMark(): MutableList<TerminalNode!>!

open fun QuotationMark(i: Int): TerminalNode!

fun basicUnescaped(): BasicUnescapedContext!

open class BasicUnescapedContext : ParserRuleContext

Module Contents

BasicUnescapedContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun binInt(): BinIntContext!

open class BinIntContext : ParserRuleContext

Module Contents

BinIntContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun BinaryInteger(): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun booleanValue(): BooleanValueContext!

open class BooleanValueContext : ParserRuleContext

Module Contents

BooleanValueContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun falseBool(): FalseBoolContext!

open fun trueBool(): TrueBoolContext!

fun date(): DateContext!

open class DateContext : ParserRuleContext

Module Contents

DateContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun Dash(): MutableList<TerminalNode!>!

open fun Dash(i: Int): TerminalNode!

open fun day(): DayContext!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun month(): MonthContext!

open fun year(): YearContext!

fun dateTime(): DateTimeContext!

open class DateTimeContext : ParserRuleContext

Module Contents

DateTimeContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun localDate(): LocalDateContext!

open fun localDateTime(): LocalDateTimeContext!

open fun localTime(): LocalTimeContext!

open fun offsetDateTime(): OffsetDateTimeContext!

fun day(): DayContext!

open class DayContext : ParserRuleContext

Module Contents

DayContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun decInt(): DecIntContext!

open class DecIntContext : ParserRuleContext

Module Contents

DecIntContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun DecimalInteger(): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun escaped(): EscapedContext!

open class EscapedContext : ParserRuleContext

Module Contents

EscapedContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun EscapeSequence(): TerminalNode!

open fun exitRule(listener: ParseTreeListener!): Unit

fun expression(): ExpressionContext!

open class ExpressionContext : ParserRuleContext

Module Contents

ExpressionContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun keyval(): KeyvalContext!

open fun table(): TableContext!

fun falseBool(): FalseBoolContext!

open class FalseBoolContext : ParserRuleContext

Module Contents

FalseBoolContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun FalseBoolean(): TerminalNode!

fun floatValue(): FloatValueContext!

open class FloatValueContext : ParserRuleContext

Module Contents

FloatValueContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun regularFloat(): RegularFloatContext!

open fun regularFloatInf(): RegularFloatInfContext!

open fun regularFloatNaN(): RegularFloatNaNContext!

fun hexInt(): HexIntContext!

open class HexIntContext : ParserRuleContext

Module Contents

HexIntContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun HexInteger(): TerminalNode!

open class HourContext : ParserRuleContext

fun hour(): HourContext!

Module Contents

HourContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun hourOffset(): HourOffsetContext!

open class HourOffsetContext : ParserRuleContext

Module Contents

HourOffsetContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun Dash(): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun Plus(): TerminalNode!

fun inlineTable(): InlineTableContext!

open class InlineTableContext : ParserRuleContext

Module Contents

InlineTableContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun InlineTableEnd(): TerminalNode!

open fun InlineTableStart(): TerminalNode!

open fun inlineTableValues(): InlineTableValuesContext!

fun inlineTableValues(): InlineTableValuesContext!

open class InlineTableValuesContext : ParserRuleContext

Module Contents

InlineTableValuesContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun keyval(): MutableList<KeyvalContext!>!

open fun keyval(i: Int): KeyvalContext!

fun integer(): IntegerContext!

open class IntegerContext : ParserRuleContext

Module Contents

IntegerContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun binInt(): BinIntContext!

open fun decInt(): DecIntContext!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun hexInt(): HexIntContext!

open fun octInt(): OctIntContext!

fun key(): KeyContext!

open class KeyContext : ParserRuleContext

Module Contents

KeyContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun Dot(): MutableList<TerminalNode!>!

open fun Dot(i: Int): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun simpleKey(): MutableList<SimpleKeyContext!>!

open fun simpleKey(i: Int): SimpleKeyContext!

fun keyval(): KeyvalContext!

open class KeyvalContext : ParserRuleContext

Module Contents

KeyvalContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun Equals(): TerminalNode!

open fun exitRule(listener: ParseTreeListener!): Unit

fun literalBody(): LiteralBodyContext!

open class LiteralBodyContext : ParserRuleContext

Module Contents

LiteralBodyContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun literalString(): LiteralStringContext!

open class LiteralStringContext : ParserRuleContext

Module Contents

LiteralStringContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun Apostrophe(): MutableList<TerminalNode!>!

open fun Apostrophe(i: Int): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun literalBody(): LiteralBodyContext!

fun localDate(): LocalDateContext!

open class LocalDateContext : ParserRuleContext

Module Contents

LocalDateContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun localDateTime(): LocalDateTimeContext!

open class LocalDateTimeContext : ParserRuleContext

Module Contents

LocalDateTimeContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun localTime(): LocalTimeContext!

open class LocalTimeContext : ParserRuleContext

Module Contents

LocalTimeContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun minute(): MinuteContext!

open class MinuteContext : ParserRuleContext

Module Contents

MinuteContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun minuteOffset(): MinuteOffsetContext!

open class MinuteOffsetContext : ParserRuleContext

Module Contents

MinuteOffsetContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun mlBasicChar(): MlBasicCharContext!

open class MlBasicCharContext : ParserRuleContext

Module Contents

MlBasicCharContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun mlBasicUnescaped(): MlBasicUnescapedContext!

fun mlBasicString(): MlBasicStringContext!

open class MlBasicStringContext : ParserRuleContext

Module Contents

MlBasicStringContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun mlBasicChar(): MutableList<MlBasicCharContext!>!

open fun mlBasicChar(i: Int): MlBasicCharContext!

open fun TripleQuotationMark(): MutableList<TerminalNode!>!

open fun TripleQuotationMark(i: Int): TerminalNode!

fun mlBasicUnescaped(): MlBasicUnescapedContext!

open class MlBasicUnescapedContext : ParserRuleContext

Module Contents

MlBasicUnescapedContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun NewLine(): TerminalNode!

fun mlLiteralBody(): MlLiteralBodyContext!

open class MlLiteralBodyContext : ParserRuleContext

Module Contents

MlLiteralBodyContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun mlLiteralString(): MlLiteralStringContext!

open class MlLiteralStringContext : ParserRuleContext

Module Contents

MlLiteralStringContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun mlLiteralBody(): MlLiteralBodyContext!

open fun TripleApostrophe(): MutableList<TerminalNode!>!

open fun TripleApostrophe(i: Int): TerminalNode!

fun month(): MonthContext!

open class MonthContext : ParserRuleContext

Module Contents

MonthContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun octInt(): OctIntContext!

open class OctIntContext : ParserRuleContext

Module Contents

OctIntContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun OctalInteger(): TerminalNode!

fun offsetDateTime(): OffsetDateTimeContext!

open class OffsetDateTimeContext : ParserRuleContext

Module Contents

OffsetDateTimeContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun timeOffset(): TimeOffsetContext!

fun quotedKey(): QuotedKeyContext!

open class QuotedKeyContext : ParserRuleContext

Module Contents

QuotedKeyContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun regularFloat(): RegularFloatContext!

open class RegularFloatContext : ParserRuleContext

Module Contents

RegularFloatContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun FloatingPoint(): TerminalNode!

fun regularFloatInf(): RegularFloatInfContext!

open class RegularFloatInfContext : ParserRuleContext

Module Contents

RegularFloatInfContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun FloatingPointInf(): TerminalNode!

fun regularFloatNaN(): RegularFloatNaNContext!

open class RegularFloatNaNContext : ParserRuleContext

Module Contents

RegularFloatNaNContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun FloatingPointNaN(): TerminalNode!

static val RULE_array: Int

static val RULE_arrayTable: Int

static val RULE_arrayValue: Int

static val RULE_arrayValues: Int

static val RULE_basicChar: Int

static val RULE_basicString: Int

static val RULE_basicUnescaped: Int

static val RULE_binInt: Int

static val RULE_booleanValue: Int

static val RULE_date: Int

static val RULE_dateTime: Int

static val RULE_day: Int

static val RULE_decInt: Int

static val RULE_escaped: Int

static val RULE_expression: Int

static val RULE_falseBool: Int

static val RULE_floatValue: Int

static val RULE_hexInt: Int

static val RULE_hour: Int

static val RULE_hourOffset: Int

static val RULE_inlineTable: Int

static val RULE_inlineTableValues: Int

static val RULE_integer: Int

static val RULE_key: Int

static val RULE_keyval: Int

static val RULE_literalBody: Int

static val RULE_literalString: Int

static val RULE_localDate: Int

static val RULE_localDateTime: Int

static val RULE_localTime: Int

static val RULE_minute: Int

static val RULE_minuteOffset: Int

static val RULE_mlBasicChar: Int

static val RULE_mlBasicString: Int

static val RULE_mlBasicUnescaped: Int

static val RULE_mlLiteralBody: Int

static val RULE_mlLiteralString: Int

static val RULE_month: Int

static val RULE_octInt: Int

static val RULE_offsetDateTime: Int

static val RULE_quotedKey: Int

static val RULE_regularFloat: Int

static val RULE_regularFloatInf: Int

static val RULE_regularFloatNaN: Int

static val RULE_second: Int

static val RULE_secondFraction: Int

static val RULE_simpleKey: Int

static val RULE_standardTable: Int

static val RULE_string: Int

static val RULE_table: Int

static val RULE_time: Int

static val RULE_timeOffset: Int

static val RULE_toml: Int

static val RULE_tomlKey: Int

static val RULE_trueBool: Int

static val RULE_unquotedKey: Int

static val RULE_val: Int

static val RULE_year: Int

fun second(): SecondContext!

open class SecondContext : ParserRuleContext

Module Contents

SecondContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun secondFraction(): SecondFractionContext!

open class SecondFractionContext : ParserRuleContext

Module Contents

SecondFractionContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun simpleKey(): SimpleKeyContext!

open class SimpleKeyContext : ParserRuleContext

Module Contents

SimpleKeyContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun quotedKey(): QuotedKeyContext!

open fun unquotedKey(): UnquotedKeyContext!

fun standardTable(): StandardTableContext!

open class StandardTableContext : ParserRuleContext

Module Contents

StandardTableContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun TableKeyEnd(): TerminalNode!

open fun TableKeyStart(): TerminalNode!

fun string(): StringContext!

open class StringContext : ParserRuleContext

Module Contents

StringContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun mlBasicString(): MlBasicStringContext!

open fun mlLiteralString(): MlLiteralStringContext!

fun table(): TableContext!

open class TableContext : ParserRuleContext

Module Contents

TableContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun arrayTable(): ArrayTableContext!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun standardTable(): StandardTableContext!

open class TimeContext : ParserRuleContext

fun time(): TimeContext!

Module Contents

TimeContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun Colon(): MutableList<TerminalNode!>!

open fun Colon(i: Int): TerminalNode!

open fun Dot(): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun minute(): MinuteContext!

open fun second(): SecondContext!

open fun secondFraction(): SecondFractionContext!

fun timeOffset(): TimeOffsetContext!

open class TimeOffsetContext : ParserRuleContext

Module Contents

TimeOffsetContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun Colon(): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun hourOffset(): HourOffsetContext!

open fun minuteOffset(): MinuteOffsetContext!

open fun Z(): TerminalNode!

open class TomlContext : ParserRuleContext

fun toml(): TomlContext!

Module Contents

TomlContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun expression(): MutableList<ExpressionContext!>!

open fun expression(i: Int): ExpressionContext!

fun tomlKey(): TomlKeyContext!

open class TomlKeyContext : ParserRuleContext

Module Contents

TomlKeyContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun trueBool(): TrueBoolContext!

open class TrueBoolContext : ParserRuleContext

Module Contents

TrueBoolContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun TrueBoolean(): TerminalNode!

fun unquotedKey(): UnquotedKeyContext!

open class UnquotedKeyContext : ParserRuleContext

Module Contents

UnquotedKeyContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun UnquotedKey(): TerminalNode!

fun val(): ValContext!

open class ValContext : ParserRuleContext

Module Contents

ValContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun array(): ArrayContext!

open fun booleanValue(): BooleanValueContext!

open fun dateTime(): DateTimeContext!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun floatValue(): FloatValueContext!

open fun inlineTable(): InlineTableContext!

open fun integer(): IntegerContext!

open fun string(): StringContext!

open class YearContext : ParserRuleContext

fun year(): YearContext!

Module Contents

YearContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open class TomlParserBaseListener :

TomlParserListener

Module Contents

TomlParserBaseListener()

open fun enterArray(ctx: ArrayContext!): Unit

open fun enterArrayTable(ctx: ArrayTableContext!): Unit

open fun enterArrayValue(ctx: ArrayValueContext!): Unit

open fun enterArrayValues(ctx: ArrayValuesContext!): Unit

open fun enterBasicChar(ctx: BasicCharContext!): Unit

open fun enterBasicString(ctx: BasicStringContext!): Unit

open fun enterBasicUnescaped(ctx: BasicUnescapedContext!): Unit

open fun enterBinInt(ctx: BinIntContext!): Unit

open fun enterBooleanValue(ctx: BooleanValueContext!): Unit

open fun enterDate(ctx: DateContext!): Unit

open fun enterDateTime(ctx: DateTimeContext!): Unit

open fun enterDay(ctx: DayContext!): Unit

open fun enterDecInt(ctx: DecIntContext!): Unit

open fun enterEscaped(ctx: EscapedContext!): Unit

open fun enterEveryRule(ctx: ParserRuleContext!): Unit

open fun enterExpression(ctx: ExpressionContext!): Unit

open fun enterFalseBool(ctx: FalseBoolContext!): Unit

open fun enterFloatValue(ctx: FloatValueContext!): Unit

open fun enterHexInt(ctx: HexIntContext!): Unit

open fun enterHour(ctx: HourContext!): Unit

open fun enterHourOffset(ctx: HourOffsetContext!): Unit

open fun enterInlineTable(ctx: InlineTableContext!): Unit

open fun enterInlineTableValues(ctx: InlineTableValuesContext!): Unit

open fun enterInteger(ctx: IntegerContext!): Unit

open fun enterKey(ctx: KeyContext!): Unit

open fun enterKeyval(ctx: KeyvalContext!): Unit

open fun enterLiteralBody(ctx: LiteralBodyContext!): Unit

open fun enterLiteralString(ctx: LiteralStringContext!): Unit

open fun enterLocalDate(ctx: LocalDateContext!): Unit

open fun enterLocalDateTime(ctx: LocalDateTimeContext!): Unit

open fun enterLocalTime(ctx: LocalTimeContext!): Unit

open fun enterMinute(ctx: MinuteContext!): Unit

open fun enterMinuteOffset(ctx: MinuteOffsetContext!): Unit

open fun enterMlBasicChar(ctx: MlBasicCharContext!): Unit

open fun enterMlBasicString(ctx: MlBasicStringContext!): Unit

open fun enterMlBasicUnescaped(ctx: MlBasicUnescapedContext!): Unit

open fun enterMlLiteralBody(ctx: MlLiteralBodyContext!): Unit

open fun enterMlLiteralString(ctx: MlLiteralStringContext!): Unit

open fun enterMonth(ctx: MonthContext!): Unit

open fun enterOctInt(ctx: OctIntContext!): Unit

open fun enterOffsetDateTime(ctx: OffsetDateTimeContext!): Unit

open fun enterQuotedKey(ctx: QuotedKeyContext!): Unit

open fun enterRegularFloat(ctx: RegularFloatContext!): Unit

open fun enterRegularFloatInf(ctx: RegularFloatInfContext!): Unit

open fun enterRegularFloatNaN(ctx: RegularFloatNaNContext!): Unit

open fun enterSecond(ctx: SecondContext!): Unit

open fun enterSecondFraction(ctx: SecondFractionContext!): Unit

open fun enterSimpleKey(ctx: SimpleKeyContext!): Unit

open fun enterStandardTable(ctx: StandardTableContext!): Unit

open fun enterString(ctx: StringContext!): Unit

open fun enterTable(ctx: TableContext!): Unit

open fun enterTime(ctx: TimeContext!): Unit

open fun enterTimeOffset(ctx: TimeOffsetContext!): Unit

open fun enterToml(ctx: TomlContext!): Unit

open fun enterTomlKey(ctx: TomlKeyContext!): Unit

open fun enterTrueBool(ctx: TrueBoolContext!): Unit

open fun enterUnquotedKey(ctx: UnquotedKeyContext!): Unit

open fun enterVal(ctx: ValContext!): Unit

open fun enterYear(ctx: YearContext!): Unit

open fun exitArray(ctx: ArrayContext!): Unit

open fun exitArrayTable(ctx: ArrayTableContext!): Unit

open fun exitArrayValue(ctx: ArrayValueContext!): Unit

open fun exitArrayValues(ctx: ArrayValuesContext!): Unit

open fun exitBasicChar(ctx: BasicCharContext!): Unit

open fun exitBasicString(ctx: BasicStringContext!): Unit

open fun exitBasicUnescaped(ctx: BasicUnescapedContext!): Unit

open fun exitBinInt(ctx: BinIntContext!): Unit

open fun exitBooleanValue(ctx: BooleanValueContext!): Unit

open fun exitDate(ctx: DateContext!): Unit

open fun exitDateTime(ctx: DateTimeContext!): Unit

open fun exitDay(ctx: DayContext!): Unit

open fun exitDecInt(ctx: DecIntContext!): Unit

open fun exitEscaped(ctx: EscapedContext!): Unit

open fun exitEveryRule(ctx: ParserRuleContext!): Unit

open fun exitExpression(ctx: ExpressionContext!): Unit

open fun exitFalseBool(ctx: FalseBoolContext!): Unit

open fun exitFloatValue(ctx: FloatValueContext!): Unit

open fun exitHexInt(ctx: HexIntContext!): Unit

open fun exitHour(ctx: HourContext!): Unit

open fun exitHourOffset(ctx: HourOffsetContext!): Unit

open fun exitInlineTable(ctx: InlineTableContext!): Unit

open fun exitInlineTableValues(ctx: InlineTableValuesContext!): Unit

open fun exitInteger(ctx: IntegerContext!): Unit

open fun exitKey(ctx: KeyContext!): Unit

open fun exitKeyval(ctx: KeyvalContext!): Unit

open fun exitLiteralBody(ctx: LiteralBodyContext!): Unit

open fun exitLiteralString(ctx: LiteralStringContext!): Unit

open fun exitLocalDate(ctx: LocalDateContext!): Unit

open fun exitLocalDateTime(ctx: LocalDateTimeContext!): Unit

open fun exitLocalTime(ctx: LocalTimeContext!): Unit

open fun exitMinute(ctx: MinuteContext!): Unit

open fun exitMinuteOffset(ctx: MinuteOffsetContext!): Unit

open fun exitMlBasicChar(ctx: MlBasicCharContext!): Unit

open fun exitMlBasicString(ctx: MlBasicStringContext!): Unit

open fun exitMlBasicUnescaped(ctx: MlBasicUnescapedContext!): Unit

open fun exitMlLiteralBody(ctx: MlLiteralBodyContext!): Unit

open fun exitMlLiteralString(ctx: MlLiteralStringContext!): Unit

open fun exitMonth(ctx: MonthContext!): Unit

open fun exitOctInt(ctx: OctIntContext!): Unit

open fun exitOffsetDateTime(ctx: OffsetDateTimeContext!): Unit

open fun exitQuotedKey(ctx: QuotedKeyContext!): Unit

open fun exitRegularFloat(ctx: RegularFloatContext!): Unit

open fun exitRegularFloatInf(ctx: RegularFloatInfContext!): Unit

open fun exitRegularFloatNaN(ctx: RegularFloatNaNContext!): Unit

open fun exitSecond(ctx: SecondContext!): Unit

open fun exitSecondFraction(ctx: SecondFractionContext!): Unit

open fun exitSimpleKey(ctx: SimpleKeyContext!): Unit

open fun exitStandardTable(ctx: StandardTableContext!): Unit

open fun exitString(ctx: StringContext!): Unit

open fun exitTable(ctx: TableContext!): Unit

open fun exitTime(ctx: TimeContext!): Unit

open fun exitTimeOffset(ctx: TimeOffsetContext!): Unit

open fun exitToml(ctx: TomlContext!): Unit

open fun exitTomlKey(ctx: TomlKeyContext!): Unit

open fun exitTrueBool(ctx: TrueBoolContext!): Unit

open fun exitUnquotedKey(ctx: UnquotedKeyContext!): Unit

open fun exitVal(ctx: ValContext!): Unit

open fun exitYear(ctx: YearContext!): Unit

open fun visitErrorNode(node: ErrorNode!): Unit

open fun visitTerminal(node: TerminalNode!): Unit

open class TomlParserBaseVisitor<T : Any!> : AbstractParseTreeVisitor<T>,

TomlParserVisitor

Module Contents

TomlParserBaseVisitor()

open fun visitArray(ctx: ArrayContext!): T

open fun visitArrayTable(ctx: ArrayTableContext!): T

open fun visitArrayValue(ctx: ArrayValueContext!): T

open fun visitArrayValues(ctx: ArrayValuesContext!): T

open fun visitBasicChar(ctx: BasicCharContext!): T

open fun visitBasicString(ctx: BasicStringContext!): T

open fun visitBasicUnescaped(ctx: BasicUnescapedContext!): T

open fun visitBinInt(ctx: BinIntContext!): T

open fun visitBooleanValue(ctx: BooleanValueContext!): T

open fun visitDate(ctx: DateContext!): T

open fun visitDateTime(ctx: DateTimeContext!): T

open fun visitDay(ctx: DayContext!): T

open fun visitDecInt(ctx: DecIntContext!): T

open fun visitEscaped(ctx: EscapedContext!): T

open fun visitExpression(ctx: ExpressionContext!): T

open fun visitFalseBool(ctx: FalseBoolContext!): T

open fun visitFloatValue(ctx: FloatValueContext!): T

open fun visitHexInt(ctx: HexIntContext!): T

open fun visitHour(ctx: HourContext!): T

open fun visitHourOffset(ctx: HourOffsetContext!): T

open fun visitInlineTable(ctx: InlineTableContext!): T

open fun visitInlineTableValues(ctx: InlineTableValuesContext!): T

open fun visitInteger(ctx: IntegerContext!): T

open fun visitKey(ctx: KeyContext!): T

open fun visitKeyval(ctx: KeyvalContext!): T

open fun visitLiteralBody(ctx: LiteralBodyContext!): T

open fun visitLiteralString(ctx: LiteralStringContext!): T

open fun visitLocalDate(ctx: LocalDateContext!): T

open fun visitLocalDateTime(ctx: LocalDateTimeContext!): T

open fun visitLocalTime(ctx: LocalTimeContext!): T

open fun visitMinute(ctx: MinuteContext!): T

open fun visitMinuteOffset(ctx: MinuteOffsetContext!): T

open fun visitMlBasicChar(ctx: MlBasicCharContext!): T

open fun visitMlBasicString(ctx: MlBasicStringContext!): T

open fun visitMlBasicUnescaped(ctx: MlBasicUnescapedContext!): T

open fun visitMlLiteralBody(ctx: MlLiteralBodyContext!): T

open fun visitMlLiteralString(ctx: MlLiteralStringContext!): T

open fun visitMonth(ctx: MonthContext!): T

open fun visitOctInt(ctx: OctIntContext!): T

open fun visitOffsetDateTime(ctx: OffsetDateTimeContext!): T

open fun visitQuotedKey(ctx: QuotedKeyContext!): T

open fun visitRegularFloat(ctx: RegularFloatContext!): T

open fun visitRegularFloatInf(ctx: RegularFloatInfContext!): T

open fun visitRegularFloatNaN(ctx: RegularFloatNaNContext!): T

open fun visitSecond(ctx: SecondContext!): T

open fun visitSecondFraction(ctx: SecondFractionContext!): T

open fun visitSimpleKey(ctx: SimpleKeyContext!): T

open fun visitStandardTable(ctx: StandardTableContext!): T

open fun visitString(ctx: StringContext!): T

open fun visitTable(ctx: TableContext!): T

open fun visitTime(ctx: TimeContext!): T

open fun visitTimeOffset(ctx: TimeOffsetContext!): T

open fun visitToml(ctx: TomlContext!): T

open fun visitTomlKey(ctx: TomlKeyContext!): T

open fun visitTrueBool(ctx: TrueBoolContext!): T

open fun visitUnquotedKey(ctx: UnquotedKeyContext!): T

open fun visitVal(ctx: ValContext!): T

open fun visitYear(ctx: YearContext!): T

interface TomlParseResult :

Module Contents

TomlParseError

interface TomlParserListener : ParseTreeListener

Module Contents

abstract fun enterArray(ctx: ArrayContext!): Unit

abstract fun enterArrayTable(ctx: ArrayTableContext!): Unit

abstract fun enterArrayValue(ctx: ArrayValueContext!): Unit

abstract fun enterArrayValues(ctx: ArrayValuesContext!): Unit

abstract fun enterBasicChar(ctx: BasicCharContext!): Unit

abstract fun enterBasicString(ctx: BasicStringContext!): Unit

abstract fun enterBasicUnescaped(ctx: BasicUnescapedContext!): Unit

abstract fun enterBinInt(ctx: BinIntContext!): Unit

abstract fun enterBooleanValue(ctx: BooleanValueContext!): Unit

abstract fun enterDate(ctx: DateContext!): Unit

abstract fun enterDateTime(ctx: DateTimeContext!): Unit

abstract fun enterDay(ctx: DayContext!): Unit

abstract fun enterDecInt(ctx: DecIntContext!): Unit

abstract fun enterEscaped(ctx: EscapedContext!): Unit

abstract fun enterExpression(ctx: ExpressionContext!): Unit

abstract fun enterFalseBool(ctx: FalseBoolContext!): Unit

abstract fun enterFloatValue(ctx: FloatValueContext!): Unit

abstract fun enterHexInt(ctx: HexIntContext!): Unit

abstract fun enterHour(ctx: HourContext!): Unit

abstract fun enterHourOffset(ctx: HourOffsetContext!): Unit

abstract fun enterInlineTable(ctx: InlineTableContext!): Unit

abstract fun enterInlineTableValues(ctx: InlineTableValuesContext!): Unit

abstract fun enterInteger(ctx: IntegerContext!): Unit

abstract fun enterKey(ctx: KeyContext!): Unit

abstract fun enterKeyval(ctx: KeyvalContext!): Unit

abstract fun enterLiteralBody(ctx: LiteralBodyContext!): Unit

abstract fun enterLiteralString(ctx: LiteralStringContext!): Unit

abstract fun enterLocalDate(ctx: LocalDateContext!): Unit

abstract fun enterLocalDateTime(ctx: LocalDateTimeContext!): Unit

abstract fun enterLocalTime(ctx: LocalTimeContext!): Unit

abstract fun enterMinute(ctx: MinuteContext!): Unit

abstract fun enterMinuteOffset(ctx: MinuteOffsetContext!): Unit

abstract fun enterMlBasicChar(ctx: MlBasicCharContext!): Unit

abstract fun enterMlBasicString(ctx: MlBasicStringContext!): Unit

abstract fun enterMlBasicUnescaped(ctx: MlBasicUnescapedContext!): Unit

abstract fun enterMlLiteralBody(ctx: MlLiteralBodyContext!): Unit

abstract fun enterMlLiteralString(ctx: MlLiteralStringContext!): Unit

abstract fun enterMonth(ctx: MonthContext!): Unit

abstract fun enterOctInt(ctx: OctIntContext!): Unit

abstract fun enterOffsetDateTime(ctx: OffsetDateTimeContext!): Unit

abstract fun enterQuotedKey(ctx: QuotedKeyContext!): Unit

abstract fun enterRegularFloat(ctx: RegularFloatContext!): Unit

abstract fun enterRegularFloatInf(ctx: RegularFloatInfContext!): Unit

abstract fun enterRegularFloatNaN(ctx: RegularFloatNaNContext!): Unit

abstract fun enterSecond(ctx: SecondContext!): Unit

abstract fun enterSecondFraction(ctx: SecondFractionContext!): Unit

abstract fun enterSimpleKey(ctx: SimpleKeyContext!): Unit

abstract fun enterStandardTable(ctx: StandardTableContext!): Unit

abstract fun enterString(ctx: StringContext!): Unit

abstract fun enterTable(ctx: TableContext!): Unit

abstract fun enterTime(ctx: TimeContext!): Unit

abstract fun enterTimeOffset(ctx: TimeOffsetContext!): Unit

abstract fun enterToml(ctx: TomlContext!): Unit

abstract fun enterTomlKey(ctx: TomlKeyContext!): Unit

abstract fun enterTrueBool(ctx: TrueBoolContext!): Unit

abstract fun enterUnquotedKey(ctx: UnquotedKeyContext!): Unit

abstract fun enterVal(ctx: ValContext!): Unit

abstract fun enterYear(ctx: YearContext!): Unit

abstract fun exitArray(ctx: ArrayContext!): Unit

abstract fun exitArrayTable(ctx: ArrayTableContext!): Unit

abstract fun exitArrayValue(ctx: ArrayValueContext!): Unit

abstract fun exitArrayValues(ctx: ArrayValuesContext!): Unit

abstract fun exitBasicChar(ctx: BasicCharContext!): Unit

abstract fun exitBasicString(ctx: BasicStringContext!): Unit

abstract fun exitBasicUnescaped(ctx: BasicUnescapedContext!): Unit

abstract fun exitBinInt(ctx: BinIntContext!): Unit

abstract fun exitBooleanValue(ctx: BooleanValueContext!): Unit

abstract fun exitDate(ctx: DateContext!): Unit

abstract fun exitDateTime(ctx: DateTimeContext!): Unit

abstract fun exitDay(ctx: DayContext!): Unit

abstract fun exitDecInt(ctx: DecIntContext!): Unit

abstract fun exitEscaped(ctx: EscapedContext!): Unit

abstract fun exitExpression(ctx: ExpressionContext!): Unit

abstract fun exitFalseBool(ctx: FalseBoolContext!): Unit

abstract fun exitFloatValue(ctx: FloatValueContext!): Unit

abstract fun exitHexInt(ctx: HexIntContext!): Unit

abstract fun exitHour(ctx: HourContext!): Unit

abstract fun exitHourOffset(ctx: HourOffsetContext!): Unit

abstract fun exitInlineTable(ctx: InlineTableContext!): Unit

abstract fun exitInlineTableValues(ctx: InlineTableValuesContext!): Unit

abstract fun exitInteger(ctx: IntegerContext!): Unit

abstract fun exitKey(ctx: KeyContext!): Unit

abstract fun exitKeyval(ctx: KeyvalContext!): Unit

abstract fun exitLiteralBody(ctx: LiteralBodyContext!): Unit

abstract fun exitLiteralString(ctx: LiteralStringContext!): Unit

abstract fun exitLocalDate(ctx: LocalDateContext!): Unit

abstract fun exitLocalDateTime(ctx: LocalDateTimeContext!): Unit

abstract fun exitLocalTime(ctx: LocalTimeContext!): Unit

abstract fun exitMinute(ctx: MinuteContext!): Unit

abstract fun exitMinuteOffset(ctx: MinuteOffsetContext!): Unit

abstract fun exitMlBasicChar(ctx: MlBasicCharContext!): Unit

abstract fun exitMlBasicString(ctx: MlBasicStringContext!): Unit

abstract fun exitMlBasicUnescaped(ctx: MlBasicUnescapedContext!): Unit

abstract fun exitMlLiteralBody(ctx: MlLiteralBodyContext!): Unit

abstract fun exitMlLiteralString(ctx: MlLiteralStringContext!): Unit

abstract fun exitMonth(ctx: MonthContext!): Unit

abstract fun exitOctInt(ctx: OctIntContext!): Unit

abstract fun exitOffsetDateTime(ctx: OffsetDateTimeContext!): Unit

abstract fun exitQuotedKey(ctx: QuotedKeyContext!): Unit

abstract fun exitRegularFloat(ctx: RegularFloatContext!): Unit

abstract fun exitRegularFloatInf(ctx: RegularFloatInfContext!): Unit

abstract fun exitRegularFloatNaN(ctx: RegularFloatNaNContext!): Unit

abstract fun exitSecond(ctx: SecondContext!): Unit

abstract fun exitSecondFraction(ctx: SecondFractionContext!): Unit

abstract fun exitSimpleKey(ctx: SimpleKeyContext!): Unit

abstract fun exitStandardTable(ctx: StandardTableContext!): Unit

abstract fun exitString(ctx: StringContext!): Unit

abstract fun exitTable(ctx: TableContext!): Unit

abstract fun exitTime(ctx: TimeContext!): Unit

abstract fun exitTimeOffset(ctx: TimeOffsetContext!): Unit

abstract fun exitToml(ctx: TomlContext!): Unit

abstract fun exitTomlKey(ctx: TomlKeyContext!): Unit

abstract fun exitTrueBool(ctx: TrueBoolContext!): Unit

abstract fun exitUnquotedKey(ctx: UnquotedKeyContext!): Unit

abstract fun exitVal(ctx: ValContext!): Unit

abstract fun exitYear(ctx: YearContext!): Unit

interface TomlParserVisitor<T : Any!> : ParseTreeVisitor<T>

Module Contents

abstract fun visitArray(ctx: ArrayContext!): T

abstract fun visitArrayTable(ctx: ArrayTableContext!): T

abstract fun visitArrayValue(ctx: ArrayValueContext!): T

abstract fun visitArrayValues(ctx: ArrayValuesContext!): T

abstract fun visitBasicChar(ctx: BasicCharContext!): T

abstract fun visitBasicString(ctx: BasicStringContext!): T

abstract fun visitBasicUnescaped(ctx: BasicUnescapedContext!): T

abstract fun visitBinInt(ctx: BinIntContext!): T

abstract fun visitBooleanValue(ctx: BooleanValueContext!): T

abstract fun visitDate(ctx: DateContext!): T

abstract fun visitDateTime(ctx: DateTimeContext!): T

abstract fun visitDay(ctx: DayContext!): T

abstract fun visitDecInt(ctx: DecIntContext!): T

abstract fun visitEscaped(ctx: EscapedContext!): T

abstract fun visitExpression(ctx: ExpressionContext!): T

abstract fun visitFalseBool(ctx: FalseBoolContext!): T

abstract fun visitFloatValue(ctx: FloatValueContext!): T

abstract fun visitHexInt(ctx: HexIntContext!): T

abstract fun visitHour(ctx: HourContext!): T

abstract fun visitHourOffset(ctx: HourOffsetContext!): T

abstract fun visitInlineTable(ctx: InlineTableContext!): T

abstract fun visitInlineTableValues(ctx: InlineTableValuesContext!): T

abstract fun visitInteger(ctx: IntegerContext!): T

abstract fun visitKey(ctx: KeyContext!): T

abstract fun visitKeyval(ctx: KeyvalContext!): T

abstract fun visitLiteralBody(ctx: LiteralBodyContext!): T

abstract fun visitLiteralString(ctx: LiteralStringContext!): T

abstract fun visitLocalDate(ctx: LocalDateContext!): T

abstract fun visitLocalDateTime(ctx: LocalDateTimeContext!): T

abstract fun visitLocalTime(ctx: LocalTimeContext!): T

abstract fun visitMinute(ctx: MinuteContext!): T

abstract fun visitMinuteOffset(ctx: MinuteOffsetContext!): T

abstract fun visitMlBasicChar(ctx: MlBasicCharContext!): T

abstract fun visitMlBasicString(ctx: MlBasicStringContext!): T

abstract fun visitMlBasicUnescaped(ctx: MlBasicUnescapedContext!): T

abstract fun visitMlLiteralBody(ctx: MlLiteralBodyContext!): T

abstract fun visitMlLiteralString(ctx: MlLiteralStringContext!): T

abstract fun visitMonth(ctx: MonthContext!): T

abstract fun visitOctInt(ctx: OctIntContext!): T

abstract fun visitOffsetDateTime(ctx: OffsetDateTimeContext!): T

abstract fun visitQuotedKey(ctx: QuotedKeyContext!): T

abstract fun visitRegularFloat(ctx: RegularFloatContext!): T

abstract fun visitRegularFloatInf(ctx: RegularFloatInfContext!): T

abstract fun visitRegularFloatNaN(ctx: RegularFloatNaNContext!): T

abstract fun visitSecond(ctx: SecondContext!): T

abstract fun visitSecondFraction(ctx: SecondFractionContext!): T

abstract fun visitSimpleKey(ctx: SimpleKeyContext!): T

abstract fun visitStandardTable(ctx: StandardTableContext!): T

abstract fun visitString(ctx: StringContext!): T

abstract fun visitTable(ctx: TableContext!): T

abstract fun visitTime(ctx: TimeContext!): T

abstract fun visitTimeOffset(ctx: TimeOffsetContext!): T

abstract fun visitToml(ctx: TomlContext!): T

abstract fun visitTomlKey(ctx: TomlKeyContext!): T

abstract fun visitTrueBool(ctx: TrueBoolContext!): T

abstract fun visitUnquotedKey(ctx: UnquotedKeyContext!): T

abstract fun visitVal(ctx: ValContext!): T

abstract fun visitYear(ctx: YearContext!): T

class TomlPosition

Module Contents

open fun contains(dottedKey: String!): Boolean

interface TomlTable

Module Contents

open fun contains(path: MutableList<String!>!): Boolean

open fun dottedKeySet(): MutableSet<String!>!

open fun dottedKeySet(includeTables: Boolean): MutableSet<String!>!

@Nullable open fun get(dottedKey: String!): Any?

@Nullable abstract fun get(path: MutableList<String!>!): Any?

@Nullable open fun getArray(dottedKey: String!):

@Nullable open fun getArray(path: MutableList<String!>!):

open fun getArrayOrEmpty(dottedKey: String!):

open fun getArrayOrEmpty(path: MutableList<String!>!):

@Nullable open fun getBoolean(dottedKey: String!): Boolean?

@Nullable open fun getBoolean(path: MutableList<String!>!): Boolean?

open fun getBoolean(dottedKey: String!, defaultValue: BooleanSupplier!): Boolean

open fun getBoolean(path: MutableList<String!>!, defaultValue: BooleanSupplier!): Boolean

@Nullable open fun getDouble(dottedKey: String!): Double?

@Nullable open fun getDouble(path: MutableList<String!>!): Double?

open fun getDouble(dottedKey: String!, defaultValue: DoubleSupplier!): Double

open fun getDouble(path: MutableList<String!>!, defaultValue: DoubleSupplier!): Double

@Nullable open fun getLocalDate(dottedKey: String!): LocalDate?

@Nullable open fun getLocalDate(path: MutableList<String!>!): LocalDate?

open fun getLocalDate(dottedKey: String!, defaultValue: Supplier<LocalDate!>!): LocalDate!

open fun getLocalDate(path: MutableList<String!>!, defaultValue: Supplier<LocalDate!>!): LocalDate!

@Nullable open fun getLocalDateTime(dottedKey: String!): LocalDateTime?

@Nullable open fun getLocalDateTime(path: MutableList<String!>!): LocalDateTime?

open fun getLocalDateTime(dottedKey: String!, defaultValue: Supplier<LocalDateTime!>!): LocalDateTime!

open fun getLocalDateTime(path: MutableList<String!>!, defaultValue: Supplier<LocalDateTime!>!): LocalDateTime!

@Nullable open fun getLocalTime(dottedKey: String!): LocalTime?

@Nullable open fun getLocalTime(path: MutableList<String!>!): LocalTime?

open fun getLocalTime(dottedKey: String!, defaultValue: Supplier<LocalTime!>!): LocalTime!

open fun getLocalTime(path: MutableList<String!>!, defaultValue: Supplier<LocalTime!>!): LocalTime!

@Nullable open fun getLong(dottedKey: String!): Long?

@Nullable open fun getLong(path: MutableList<String!>!): Long?

open fun getLong(dottedKey: String!, defaultValue: LongSupplier!): Long

open fun getLong(path: MutableList<String!>!, defaultValue: LongSupplier!): Long

@Nullable open fun getOffsetDateTime(dottedKey: String!): OffsetDateTime?

@Nullable open fun getOffsetDateTime(path: MutableList<String!>!): OffsetDateTime?

open fun getOffsetDateTime(dottedKey: String!, defaultValue: Supplier<OffsetDateTime!>!): OffsetDateTime!

open fun getOffsetDateTime(path: MutableList<String!>!, defaultValue: Supplier<OffsetDateTime!>!): OffsetDateTime!

@Nullable open fun getString(dottedKey: String!): String?

@Nullable open fun getString(path: MutableList<String!>!): String?

open fun getString(dottedKey: String!, defaultValue: Supplier<String!>!): String!

open fun getString(path: MutableList<String!>!, defaultValue: Supplier<String!>!): String!

@Nullable open fun getTable(dottedKey: String!):

@Nullable open fun getTable(path: MutableList<String!>!):

open fun getTableOrEmpty(dottedKey: String!):

open fun getTableOrEmpty(path: MutableList<String!>!):

@Nullable open fun inputPositionOf(dottedKey: String!):

@Nullable abstract fun inputPositionOf(path: MutableList<String!>!):

open fun isArray(dottedKey: String!): Boolean

open fun isArray(path: MutableList<String!>!): Boolean

open fun isBoolean(dottedKey: String!): Boolean

open fun isBoolean(path: MutableList<String!>!): Boolean

open fun isDouble(dottedKey: String!): Boolean

open fun isDouble(path: MutableList<String!>!): Boolean

open fun isLocalDate(dottedKey: String!): Boolean

open fun isLocalDate(path: MutableList<String!>!): Boolean

open fun isLocalDateTime(dottedKey: String!): Boolean

open fun isLocalDateTime(path: MutableList<String!>!): Boolean

open fun isLocalTime(dottedKey: String!): Boolean

open fun isLocalTime(path: MutableList<String!>!): Boolean

open fun isLong(dottedKey: String!): Boolean

open fun isLong(path: MutableList<String!>!): Boolean

open fun isOffsetDateTime(dottedKey: String!): Boolean

open fun isOffsetDateTime(path: MutableList<String!>!): Boolean

open fun isString(dottedKey: String!): Boolean

open fun isString(path: MutableList<String!>!): Boolean

open fun isTable(dottedKey: String!): Boolean

open fun isTable(path: MutableList<String!>!): Boolean

open fun keyPathSet(): MutableSet<MutableList<String!>!>!

abstract fun keyPathSet(includeTables: Boolean): MutableSet<MutableList<String!>!>!

abstract fun toMap(): MutableMap<String!, Any!>!

Module Contents

Module Contents

gasPrice

gasLimit

@Nullable

value

payload

keyPair

KeyPair

)

gasPrice

gasLimit

@Nullable

value

payload

keyPair

KeyPair

@Nullable

chainId

Int

)

gasPrice

gasLimit

@Nullable

value

payload

@Nullable

chainId

Int

signature

Signature

)

@Nullable fun extractPublicKey(): PublicKey?

)

lenient

Boolean

)

@Nullable fun getSender():

fun getChainId(): Int!

fun getSignature(): Signature!

@Nullable fun getTo():

fun isContractCreation(): Boolean

)

static fun signatureData(nonce:

gasPrice

gasLimit

@Nullable

value

payload

@Nullable

chainId

Int

)

class TransactionalEVMHostContext : HostContext

)

Unit

Module Contents

TransactionalEVMHostContext(repository:

ethereumVirtualMachine

depth

Int

sender

destination

value

code

gas

gasPrice

currentCoinbase

currentNumber

Long

currentTimestamp

Long

currentGasLimit

Long

currentDifficulty

val accountChanges: HashMap<

)

HashMap

fun accountExists(bytes: ByteArray): Boolean

val accountsToDestroy: MutableList<

val balanceChanges: HashMap<

fun call(msg: ByteBuffer): ByteBuffer

val currentDifficulty:

val currentGasLimit: Long

val currentNumber: Long

val currentTimestamp: Long

val depth: Int

val destination:

fun emitLog(address: ByteArray, data: ByteArray, dataSize: Int, topics: Array<ByteArray>, topicCount: Int): Unit

val ethereumVirtualMachine:

fun getBalance(addressBytes: ByteArray): ByteBuffer

fun getBlockHash(number: Long): ByteBuffer

fun getCode(address: ByteArray): ByteBuffer

fun getCodeHash(address: ByteArray): ByteBuffer

fun getCodeSize(address: ByteArray): Int

fun getStorage(addressBytes: ByteArray, keyBytes: ByteArray): ByteBuffer

fun getTxContext(): ByteBuffer

val logs: MutableList<

fun selfdestruct(address: ByteArray, beneficiary: ByteArray): Unit

val sender:

fun setStorage(addressBytes: ByteArray, keyBytes: ByteArray, valueBytes: ByteArray): Int

val value:

interface TransactionPool

Module Contents

abstract suspend fun add(transaction:

abstract suspend fun contains(hash:

)

Unit

)

Boolean

)

TransactionReceipt(stateRoot:

class TransactionReceipt

Module Contents

cumulativeGasUsed

Long

bloomFilter

logs

MutableList

TransactionReceipt(status: Int, cumulativeGasUsed: Long, bloomFilter:

)

logs

MutableList

)

)

fun getBloomFilter():

fun getCumulativeGasUsed(): Long

fun getLogs(): MutableList<

fun getStatus(): Int!

fun isValid(): Boolean

)

enum class TransactionReceiptFields

)

Unit

Module Contents

BLOCK_HASH

BLOOM_FILTER

CUMULATIVE_GAS_USED

class TrustManagerFactories

Module Contents

Module Contents

static fun recordClientFingerprints(knownClientsFile: Path!): TrustManagerFactory!

static fun recordClientFingerprints(knownClientsFile: Path!, skipCASigned: Boolean): TrustManagerFactory!

)

TrustManagerFactory

static fun recordClientFingerprints(knownClientsFile: Path!, tmf: TrustManagerFactory!): TrustManagerFactory!

skipCASigned

Boolean

)

TrustManagerFactory

static fun recordServerFingerprints(knownServersFile: Path!): TrustManagerFactory!

tmf

TrustManagerFactory

)

TrustManagerFactory

static fun recordServerFingerprints(knownServersFile: Path!, skipCASigned: Boolean): TrustManagerFactory!

)

TrustManagerFactory

static fun recordServerFingerprints(knownServersFile: Path!, tmf: TrustManagerFactory!): TrustManagerFactory!

skipCASigned

Boolean

)

TrustManagerFactory

static fun trustClientOnFirstAccess(knownClientsFile: Path!): TrustManagerFactory!

tmf

TrustManagerFactory

)

TrustManagerFactory

static fun trustClientOnFirstAccess(knownClientsFile: Path!, acceptCASigned: Boolean): TrustManagerFactory!

)

TrustManagerFactory

static fun trustClientOnFirstAccess(knownClientsFile: Path!, tmf: TrustManagerFactory!): TrustManagerFactory!

acceptCASigned

Boolean

)

TrustManagerFactory

static fun trustServerOnFirstUse(knownServersFile: Path!): TrustManagerFactory!

tmf

TrustManagerFactory

)

TrustManagerFactory

static fun trustServerOnFirstUse(knownServersFile: Path!, acceptCASigned: Boolean): TrustManagerFactory!

)

TrustManagerFactory

static fun trustServerOnFirstUse(knownServersFile: Path!, tmf: TrustManagerFactory!): TrustManagerFactory!

acceptCASigned

Boolean

)

TrustManagerFactory

static fun whitelistClients(knownClientsFile: Path!): TrustManagerFactory!

tmf

TrustManagerFactory

)

TrustManagerFactory

static fun whitelistClients(knownClientsFile: Path!, acceptCASigned: Boolean): TrustManagerFactory!

)

TrustManagerFactory

static fun whitelistClients(knownClientsFile: Path!, tmf: TrustManagerFactory!): TrustManagerFactory!

acceptCASigned

Boolean

)

TrustManagerFactory

static fun whitelistServers(knownServersFile: Path!): TrustManagerFactory!

tmf

TrustManagerFactory

)

TrustManagerFactory

static fun whitelistServers(knownServersFile: Path!, acceptCASigned: Boolean): TrustManagerFactory!

)

TrustManagerFactory

static fun whitelistServers(knownServersFile: Path!, tmf: TrustManagerFactory!): TrustManagerFactory!

acceptCASigned

Boolean

)

TrustManagerFactory

UI(port: Int = 0, networkInterface: String = "127.0.0.1", path: String = "/", client:

tmf

TrustManagerFactory

)

TrustManagerFactory

Module Contents

)

Module Contents

)

val networkInterface: String

Module Contents

)

modulus

)

)

)

)

)

Int

)

fun divideCeil(value:

)

fun divideCeil(value: Long):

)

)

)

fun mod0(modulus: Long):

)

modulus

)

)

)

)

)

)

fun toUInt256():

)

)

Module Contents

max

(

)

interface UInt256Value<T :

min

(

)

Comparable

Module Contents

)

)

abstract fun divideCeil(value: T): T

abstract fun divideCeil(value: Long): T

)

abstract fun mod0(modulus:

abstract fun mod0(modulus: Long): T

)

)

abstract fun multiplyMod(value: Long, modulus: Long): T

)

open fun plus(value: T): T

open fun plus(value: Long): T

)

abstract fun toUInt256():

Module Contents

)

modulus

)

)

)

)

)

Int

)

fun divide(value: Int):

)

byteOrder

ByteOrder

)

fun multiply(value: Int):

)

fun mod(modulus: Int):

)

modulus

)

fun multiplyMod(value: Int, modulus:

)

fun multiplyMod(value: Int, modulus: Int):

)

)

)

fun subtract(value: Int):

)

fun toUInt32():

static fun valueOf(value: Int):

)

)

Module Contents

max

(

)

interface UInt32Value<T :

min

(

)

Comparable

Module Contents

abstract fun add(value: Int): T

open fun addExact(value: Int): T

)

)

abstract fun divide(value: Int): T

abstract fun mod(modulus: Int): T

)

abstract fun multiply(value: Int): T

abstract fun multiplyMod(value: Int, modulus:

)

abstract fun multiplyMod(value: Int, modulus: Int): T

)

)

abstract fun subtract(value: Int): T

open fun subtractExact(value: Int): T

abstract fun toUInt32():

Module Contents

)

modulus

)

)

)

)

)

Int

)

)

)

)

modulus

)

)

)

)

)

)

fun toUInt384():

)

)

Module Contents

max

(

)

interface UInt384Value<T :

min

(

)

Comparable

Module Contents

)

)

)

)

abstract fun multiplyMod(value: Long, modulus: Long): T

)

)

abstract fun toUInt384():

Module Contents

)

modulus

)

)

)

)

)

Int

)

)

)

)

modulus

)

)

)

)

)

static fun random():

)

fun toUInt64():

)

)

Module Contents

max

(

)

interface UInt64Value<T :

min

(

)

Comparable

Module Contents

)

)

)

)

abstract fun multiplyMod(value: Long, modulus: Long): T

)

)

abstract fun toUInt64():

open class UpdateNameMessage :

UpdateNameMessage(name: String!, about: String!)

Module Contents

UpdateNameMessage()

open fun getAbout(): String!

open class VertxExtension : ParameterResolver, AfterAllCallback

var name: String!

var type: String!

Module Contents

VertxExtension()

open fun afterAll(context: ExtensionContext!): Unit

open fun resolveParameter(parameterContext: ParameterContext!, extensionContext: ExtensionContext!): Any!

open fun supportsParameter(parameterContext: ParameterContext!, extensionContext: ExtensionContext!): Boolean

class VertxGossipServer

Module Contents

VertxGossipServer(vertx: Vertx!, networkInterface: String!, port: Int, messageHashing:

MessageHashing

peerRepository

fun connectTo(host: String!, port: Int):

payloadListener

MessageListener

@Nullable

payloadValidator

MessageValidator

@Nullable

peerPruningFunction

PeerPruning

graftDelay

Int

lazyQueueInterval

Int

)

fun gossip(attributes: String!, message:

@Target([AnnotationTarget.VALUE_PARAMETER]) class VertxInstance

)

Unit

Module Contents

VertxInstance()

class VertxRLPxService :

VertxRLPxService(vertx: Vertx!, listenPort: Int, networkInterface: String!, advertisedPort: Int, identityKeyPair: KeyPair!, subProtocols: MutableList<

Module Contents

VertxRLPxService(vertx: Vertx!, listenPort: Int, networkInterface: String!, advertisedPort: Int, identityKeyPair: KeyPair!, subProtocols: MutableList<

clientId

String

)

clientId

String

repository

fun actualSocketAddress(): InetSocketAddress!

)

fun actualPort(): Int

fun addToKeepAliveList(peerPublicKey: PublicKey!): Boolean

fun advertisedPort(): Int

fun connectTo(peerPublicKey: PublicKey!, peerAddress: InetSocketAddress!):

fun disconnect(connection:

disconnectReason

fun getClient(subProtocolIdentifier:

)

Unit

)

fun repository():

fun send(subProtocolIdentifier:

messageType

Int

connection

message

static fun recordClientFingerprints(knownClientsFile: Path!): TrustOptions!

)

Unit

class VertxTrustOptions

Module Contents

static fun recordClientFingerprints(knownClientsFile: Path!, skipCASigned: Boolean): TrustOptions!

)

TrustOptions

static fun recordClientFingerprints(knownClientsFile: Path!, tmf: TrustManagerFactory!): TrustOptions!

skipCASigned

Boolean

)

TrustOptions

static fun recordServerFingerprints(knownServersFile: Path!): TrustOptions!

tmf

TrustManagerFactory

)

TrustOptions

static fun recordServerFingerprints(knownServersFile: Path!, skipCASigned: Boolean): TrustOptions!

)

TrustOptions

static fun recordServerFingerprints(knownServersFile: Path!, tmf: TrustManagerFactory!): TrustOptions!

skipCASigned

Boolean

)

TrustOptions

static fun trustClientOnFirstAccess(knownClientsFile: Path!): TrustOptions!

tmf

TrustManagerFactory

)

TrustOptions

static fun trustClientOnFirstAccess(knownClientsFile: Path!, acceptCASigned: Boolean): TrustOptions!

)

TrustOptions

static fun trustClientOnFirstAccess(knownClientsFile: Path!, tmf: TrustManagerFactory!): TrustOptions!

acceptCASigned

Boolean

)

TrustOptions

static fun trustServerOnFirstUse(knownServersFile: Path!): TrustOptions!

tmf

TrustManagerFactory

)

TrustOptions

static fun trustServerOnFirstUse(knownServersFile: Path!, acceptCASigned: Boolean): TrustOptions!

)

TrustOptions

static fun trustServerOnFirstUse(knownServersFile: Path!, tmf: TrustManagerFactory!): TrustOptions!

acceptCASigned

Boolean

)

TrustOptions

static fun whitelistClients(knownClientsFile: Path!): TrustOptions!

tmf

TrustManagerFactory

)

TrustOptions

static fun whitelistClients(knownClientsFile: Path!, acceptCASigned: Boolean): TrustOptions!

)

TrustOptions

static fun whitelistClients(knownClientsFile: Path!, tmf: TrustManagerFactory!): TrustOptions!

acceptCASigned

Boolean

)

TrustOptions

static fun whitelistServers(knownServersFile: Path!): TrustOptions!

tmf

TrustManagerFactory

)

TrustOptions

static fun whitelistServers(knownServersFile: Path!, acceptCASigned: Boolean): TrustOptions!

)

TrustOptions

static fun whitelistServers(knownServersFile: Path!, tmf: TrustManagerFactory!): TrustOptions!

acceptCASigned

Boolean

)

TrustOptions

Wallet(file: Path, password: String)

tmf

TrustManagerFactory

)

TrustOptions

class Wallet

Module Contents

fun address():

fun create(file: Path, password: String):

fun open(file: Path, password: String):

gasPrice

gasLimit

value

payload

chainId

Int

)

fun verify(tx:

)

Boolean

class Wei :

BaseUInt256Value

static fun fromEth(ethValue: Long):

Module Contents

)

open class WhoAmIResponse

Module Contents

WhoAmIResponse()

WhoAmIResponse(id: String!)

abstract fun agreedSubprotocols(): MutableCollection<

interface WireConnection

Module Contents

abstract fun onEvent(event: Event!): Unit

class Event

Module Contents

CONNECTED

DISCONNECTED

interface EventListener

Module Contents

abstract fun getDisconnectReason():

abstract fun getPeerHello():

abstract fun isDisconnectReceived(): Boolean

abstract fun isDisconnectRequested(): Boolean

abstract fun peerHost(): String!

abstract fun peerPort(): Int

abstract fun peerPublicKey(): PublicKey!

abstract fun registerListener(listener: EventListener!): Unit

class WireConnectionPeerRepositoryAdapter :

)

Boolean

open fun uri(): String!

WireConnectionPeerRepositoryAdapter(peerRepository:

Module Contents

)

fun add(wireConnection:

fun addConnectionListener(listener: Listener): Unit

)

String

fun addDisconnectionListener(listener: Listener): Unit

fun asIterable(): Iterable<

fun asIterable(identifier:

interface WireConnectionRepository

)

Iterable

Module Contents

abstract fun add(wireConnection:

abstract fun addConnectionListener(listener: Listener!): Unit

)

String

abstract fun addDisconnectionListener(listener: Listener!): Unit

abstract fun asIterable(): MutableIterable<

abstract fun asIterable(identifier:

)

MutableIterable

@Nullable abstract fun get(id: String!):

abstract fun connectionEvent(conn:

interface Listener

Module Contents

)

Unit

class XChaCha20Poly1305

Module Contents

key

Key

nonce

Nonce

)

@Nullable static fun decrypt(cipherText: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

data

key

Key

nonce

Nonce

)

@Nullable static fun decrypt(cipherText: ByteArray!, data: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

static fun decryptDetached(cipherText:

mac

key

Key

nonce

Nonce

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

mac

data

key

Key

nonce

Nonce

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, data: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

key

Key

nonce

Nonce

)

static fun encrypt(message: ByteArray!, key: Key!, nonce: Nonce!): ByteArray!

data

key

Key

nonce

Nonce

)

static fun encrypt(message: ByteArray!, data: ByteArray!, key: Key!, nonce: Nonce!): ByteArray!

key

Key

nonce

Nonce

)

static fun encryptDetached(message: ByteArray!, key: Key!, nonce: Nonce!):

data

key

Key

nonce

Nonce

)

static fun encryptDetached(message: ByteArray!, data: ByteArray!, key: Key!, nonce: Nonce!):

static fun isSecretStreamAvailable(): Boolean

Module Contents

)

Key

Module Contents

)

Nonce

static fun openDecryptionStream(key: Key!, : ByteArray!):

SecretDecryptionStream

static fun openEncryptionStream(key: Key!):

SecretEncryptionStream

package org.apache.tuweni.bytes

Module Contents

abstract class AbstractBytes :

Module Contents

AbstractBytes()

interface Bytes : Comparable<

Module Contents

)

and

(

other

open fun <T : Appendable!> appendHexTo(appendable: T): T

result

)

open fun appendTo(byteBuffer: ByteBuffer!): Unit

open fun appendTo(buffer: Buffer!): Unit

open fun commonPrefix(other:

)

open fun commonPrefixLength(other:

)

Int

open static fun concatenate(values: MutableList<

)

Int

)

open static fun concatenate(vararg values:

)

)

Unit

destinationOffset

Int

)

Unit

open static fun fromBase64String(str: CharSequence!):

open static fun fromHexString(str: CharSequence!, destinationSize: Int):

open static fun fromHexStringLenient(str: CharSequence!):

open static fun fromHexStringLenient(str: CharSequence!, destinationSize: Int):

abstract fun get(i: Int): Byte

open fun getInt(i: Int): Int

open fun getInt(i: Int, order: ByteOrder!): Int

open fun getLong(i: Int): Long

open fun getLong(i: Int, order: ByteOrder!): Long

open fun hasLeadingZero(): Boolean

open fun hasLeadingZeroByte(): Boolean

open fun isEmpty(): Boolean

open static fun minimalBytes(value: Long):

open fun numberOfLeadingZeroBytes(): Int

not

(

result

)

open fun numberOfTrailingZeroBytes(): Int

open static fun ofUnsignedInt(value: Long):

open static fun ofUnsignedInt(value: Long, order: ByteOrder!):

open static fun ofUnsignedLong(value: Long):

open static fun ofUnsignedLong(value: Long, order: ByteOrder!):

open static fun ofUnsignedShort(value: Int):

open static fun ofUnsignedShort(value: Int, order: ByteOrder!):

)

(

other

open static fun random(size: Int):

result

)

open static fun random(size: Int, generator: Random!):

open fun reverse():

shiftLeft

(

distance

Int

result

)

shiftRight

(

distance

Int

result

)

open fun slice(i: Int):

abstract fun slice(i: Int, length: Int):

open fun toArray(): ByteArray!

open fun toArray(byteOrder: ByteOrder!): ByteArray!

open fun toArrayUnsafe(): ByteArray!

open fun toBase64String(): String!

open fun toBigInteger(order: ByteOrder!): BigInteger!

open fun toEllipsisHexString(): String!

open fun toInt(order: ByteOrder!): Int

open fun toInt(): Int

open fun toLong(order: ByteOrder!): Long

open fun toQuantityHexString(): String!

open fun toUnprefixedHexString(): String!

open fun toUnsignedBigInteger(): BigInteger!

open fun toUnsignedBigInteger(order: ByteOrder!): BigInteger!

open fun trimLeadingZeros():

open fun update(digest: MessageDigest!): Unit

open static fun wrap(value: ByteArray!, offset: Int, length: Int):

open static fun wrap(vararg values:

)

open static fun wrapBuffer(buffer: Buffer!, offset: Int, size: Int):

open static fun wrapByteBuf(byteBuf: ByteBuf!, offset: Int, size: Int):

open static fun wrapByteBuffer(byteBuffer: ByteBuffer!):

open static fun wrapByteBuffer(byteBuffer: ByteBuffer!, offset: Int, size: Int):

)

xor

(

other

result

)

Module Contents

)

open static fun fromHexStringLenient(str: CharSequence!):

open static fun fromHexStringStrict(str: CharSequence!):

)

)

)

open static fun wrap(bytes: ByteArray!, offset: Int):

)

offset

Int

)

)

Module Contents

)

open static fun fromHexStringLenient(str: CharSequence!):

open static fun fromHexStringStrict(str: CharSequence!):

)

)

)

open static fun wrap(bytes: ByteArray!, offset: Int):

)

open class DelegatingBytes :

offset

Int

)

)

protected DelegatingBytes(delegate:

Module Contents

)

open class DelegatingBytes32 :

protected DelegatingBytes32(delegate:

Module Contents

)

open class DelegatingBytes48 :

protected DelegatingBytes48(delegate:

Module Contents

)

open class MutableByteBufferWrappingBytes : ByteBufferWrappingBytes,

Module Contents

open fun mutableSlice(i: Int, length: Int):

open fun set(i: Int, b: Byte): Unit

interface MutableBytes :

open static fun create(size: Int):

Module Contents

open fun clear(): Unit

open fun decrement():

open fun fill(b: Byte): Unit

open fun increment():

abstract fun mutableSlice(i: Int, length: Int):

abstract fun set(i: Int, b: Byte): Unit

open fun set(offset: Int, bytes:

)

Unit

open static fun wrap(value: ByteArray!, offset: Int, length: Int):

open static fun wrapBuffer(buffer: Buffer!, offset: Int, size: Int):

open static fun wrapByteBuf(byteBuf: ByteBuf!, offset: Int, size: Int):

open static fun wrapByteBuffer(byteBuffer: ByteBuffer!):

open static fun wrapByteBuffer(byteBuffer: ByteBuffer!, offset: Int, size: Int):

interface MutableBytes32 :

Module Contents

open static fun wrap(value: ByteArray!, offset: Int):

)

offset

Int

)

interface MutableBytes48 :

Module Contents

open static fun wrap(value: ByteArray!, offset: Int):

)

offset

Int

)

package org.apache.tuweni.concurrent

Module Contents

interface AsyncCompletion

Module Contents

abstract fun accept(consumer: Consumer<in Throwable!>!):

open static fun allOf(vararg cs:

)

open static fun allOf(cs: MutableCollection<

)

open static fun allOf(cs: Stream<

)

open static fun completed():

static val COMPLETED:

open static fun exceptional(ex: Throwable!):

abstract fun exceptionally(consumer: Consumer<in Throwable!>!):

open static fun executeBlocking(action: Runnable!):

open static fun executeBlocking(executor: Executor!, action: Runnable!):

open static fun executeBlocking(vertx: Vertx!, action: Runnable!):

open static fun executeBlocking(executor: WorkerExecutor!, action: Runnable!):

abstract fun handle(fn: Function<in Throwable!, out U>!):

open static fun incomplete():

abstract fun join(): Unit

abstract fun join(timeout: Long, unit: TimeUnit!): Unit

open static fun runOnContext(vertx: Vertx!, fn: Supplier<out

)

open static fun runOnContext(vertx: Vertx!, action: Runnable!):

abstract fun then(fn: Supplier<out

)

abstract fun thenApply(other:

out

Function

out

)

)

abstract fun thenCompose(fn: Supplier<out

)

abstract fun thenConsume(other:

out

consumer

Consumer

)

abstract fun thenSchedule(vertx: Vertx!, fn: Supplier<out

)

abstract fun thenScheduleBlockingRun(vertx: Vertx!, runnable: Runnable!):

abstract fun thenScheduleBlockingRun(executor: WorkerExecutor!, runnable: Runnable!):

abstract fun thenScheduleRun(vertx: Vertx!, runnable: Runnable!):

abstract fun thenSupply(supplier: Supplier<out U>!):

abstract fun thenSupply(vertx: Vertx!, supplier: Supplier<out U>!):

abstract fun toFuture(): Future<Void!>!

abstract fun whenComplete(consumer: Consumer<in Throwable!>!):

interface AsyncResult<T : Any!>

Module Contents

abstract fun accept(consumer: BiConsumer<in T, Throwable!>!):

open static fun allOf(vararg rs:

)

open static fun allOf(rs: MutableCollection<out

)

open static fun allOf(rs: Stream<out

)

open static fun <T : Any!> combine(rs: MutableCollection<out

out

)

open static fun <T : Any!> combine(rs: Stream<out

MutableList

out

)

open static fun <T : Any!> completed(@Nullable value: T?):

MutableList

open static fun <T : Any!> exceptional(ex: Throwable!):

abstract fun exceptionally(fn: Function<Throwable!, out T>!):

open static fun <T : Any!> executeBlocking(fn: Supplier<T>!):

open static fun <T : Any!> executeBlocking(executor: Executor!, fn: Supplier<T>!):

open static fun <T : Any!> executeBlocking(vertx: Vertx!, fn: Supplier<T>!):

open static fun <T : Any!> executeBlocking(executor: WorkerExecutor!, fn: Supplier<T>!):

@Nullable abstract fun get(): T?

@Nullable abstract fun get(timeout: Long, unit: TimeUnit!): T?

abstract fun handle(fn: BiFunction<in T, Throwable!, out U>!):

open static fun <T : Any!> incomplete():

open static fun <T : Any!> runOnContext(vertx: Vertx!, fn: Supplier<out

)

abstract fun then(fn: Function<in T, out

)

abstract fun thenAccept(consumer: Consumer<in T>!):

abstract fun thenAcceptBoth(other:

out

consumer

BiConsumer

)

abstract fun thenApply(fn: Function<in T, out U>!):

out

BiFunction

out

)

abstract fun thenCompose(fn: Function<in T, out

)

abstract fun thenSchedule(vertx: Vertx!, fn: Function<in T, out

)

abstract fun thenScheduleApply(vertx: Vertx!, fn: Function<in T, out U>!):

abstract fun thenScheduleBlockingApply(vertx: Vertx!, fn: Function<in T, out U>!):

abstract fun thenScheduleBlockingApply(executor: WorkerExecutor!, fn: Function<in T, out U>!):

abstract fun thenScheduleBlockingRun(vertx: Vertx!, runnable: Runnable!):

abstract fun thenScheduleBlockingRun(executor: WorkerExecutor!, runnable: Runnable!):

abstract fun thenScheduleRun(vertx: Vertx!, runnable: Runnable!):

abstract fun whenComplete(action: BiConsumer<in T, in Throwable!>!):

interface CompletableAsyncCompletion :

abstract fun complete(): Boolean

Module Contents

abstract fun completeExceptionally(ex: Throwable!): Boolean

abstract fun toFuture(): CompletableFuture<Void!>!

interface CompletableAsyncResult<T : Any!> :

abstract fun complete(@Nullable value: T?): Boolean

Module Contents

abstract fun completeExceptionally(ex: Throwable!): Boolean

class ExpiringMap<K : Any!, V : Any!> : MutableMap<K, V>

Module Contents

ExpiringMap()

fun compute(key: K, remappingFunction: BiFunction<in K, in V?, out V?>): V?

fun computeIfAbsent(key: K, mappingFunction: Function<in K, out V>): V

fun computeIfPresent(key: K, remappingFunction: BiFunction<in K, in V, out V?>): V?

fun containsKey(key: K): Boolean

fun containsValue(value: V): Boolean

val entries: MutableSet<MutableEntry<K, V>>

fun forEach(action: BiConsumer<in K, in V>): Unit

@Nullable fun get(key: K): V?

fun getOrDefault(key: K, defaultValue: V): V

fun merge(key: K, value: V, remappingFunction: BiFunction<in V, in V, out V?>): V?

val keys: MutableSet<K>

@Nullable fun put(key: K, value: V): V?

@Nullable fun put(key: K, value: V, expiry: Long): V?

@Nullable fun put(key: K, value: V, expiry: Long, @Nullable expiryListener: BiConsumer<K, V>?): V?

fun putAll(from: Map<out K, V>): Unit

@Nullable fun putIfAbsent(key: K, value: V): V?

@Nullable fun putIfAbsent(key: K, value: V, expiry: Long): V?

@Nullable fun putIfAbsent(key: K, value: V, expiry: Long, @Nullable expiryListener: BiConsumer<K, V>?): V?

fun remove(key: K): V?

fun remove(key: K, value: V): Boolean

fun replace(key: K, value: V): V?

fun replace(key: K, oldValue: V, newValue: V): Boolean

fun replaceAll(function: BiFunction<in K, in V, out V>): Unit

val values: MutableCollection<V>

class ExpiringSet<E : Any!> : MutableSet<E>

Module Contents

ExpiringSet(evictionTimeout: Long)

ExpiringSet()

fun add(element: E): Boolean

fun add(element: E, expiry: Long): Boolean

fun add(element: E, expiry: Long, @Nullable expiryListener: Consumer<E>?): Boolean

fun addAll(elements: Collection<E>): Boolean

fun contains(element: E): Boolean

fun containsAll(elements: Collection<E>): Boolean

fun iterator(): MutableIterator<E>

fun remove(element: E): Boolean

fun removeAll(elements: Collection<E>): Boolean

fun retainAll(elements: Collection<E>): Boolean

fun toArray(): Array<Any!>!

fun <T : Any!> toArray(a: Array<T>!): Array<T>!

package org.apache.tuweni.concurrent.coroutines

Module Contents

kotlinx.coroutines.CoroutineScope

Module Contents

fun CoroutineScope.asyncCompletion(context: CoroutineContext = Dispatchers.Default, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> Unit):

fun <T> CoroutineScope.asyncResult(context: CoroutineContext = Dispatchers.Default, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> T):

suspend fun <R> CoroutineScope.retry(retryDelay: Long, block: suspend (Int) -> R?): R

suspend fun <R> CoroutineScope.retry(retryDelay: Long, maxRetries: Int, block: suspend (Int) -> R?): R?

suspend fun <R> CoroutineScope.retry(retryDelay: (Int) -> Long?, block: suspend (Int) -> R?): R?

kotlinx.coroutines.Deferred

Module Contents

fun Deferred<Unit>.asAsyncCompletion():

fun <T> Deferred<T>.asAsyncResult():

fun Job.asAsyncCompletion():

kotlinx.coroutines.Job

Module Contents

org.apache.tuweni.concurrent.AsyncCompletion

Module Contents

fun

asDeferred

(

)

Deferred

Unit

suspend fun

org.apache.tuweni.concurrent.AsyncResult

await

(

)

Unit

Module Contents

fun <T>

asDeferred

(

)

Deferred

suspend fun <T>

suspend fun <R> timeoutAndRetry(timeout: Long, block: suspend (Int) -> R?): R

await

(

)

suspend fun <R> timeoutAndRetry(timeout: Long, maxRetries: Int, block: suspend (Int) -> R?): R?

suspend fun <R> timeoutAndRetry(timeout: (Int) -> Long?, block: suspend (Int) -> R?): R?

package org.apache.tuweni.config

Module Contents

interface Configuration

Module Contents

open static fun canonicalKey(key: String!): String!

abstract fun contains(key: String!): Boolean

open static fun empty():

open static fun empty(@Nullable schema:

)

open static fun fromToml(toml: String!):

open static fun fromToml(toml: String!, @Nullable schema:

)

open static fun fromToml(file: Path!):

open static fun fromToml(file: Path!, @Nullable schema:

)

open static fun fromToml(is: InputStream!):

open static fun fromToml(is: InputStream!, @Nullable schema:

)

@Nullable abstract fun get(key: String!): Any?

abstract fun getBoolean(key: String!): Boolean

abstract fun getConfigurationSection(name: String!):

abstract fun getDouble(key: String!): Double

abstract fun getInteger(key: String!): Int

abstract fun getList(key: String!): MutableList<Any!>!

abstract fun getListOfBoolean(key: String!): MutableList<Boolean!>!

abstract fun getListOfDouble(key: String!): MutableList<Double!>!

abstract fun getListOfInteger(key: String!): MutableList<Int!>!

abstract fun getListOfLong(key: String!): MutableList<Long!>!

abstract fun getListOfMap(key: String!): MutableList<MutableMap<String!, Any!>!>!

abstract fun getListOfString(key: String!): MutableList<String!>!

abstract fun getLong(key: String!): Long

abstract fun getMap(key: String!): MutableMap<String!, Any!>!

abstract fun getString(key: String!): String!

@Nullable abstract fun inputPositionOf(key: String!):

abstract fun keySet(prefix: String!): MutableSet<String!>!

abstract fun sections(prefix: String!): MutableSet<String!>!

open fun toToml(): String!

open fun toToml(path: Path!): Unit

abstract fun toToml(appendable: Appendable!): Unit

class ConfigurationError : RuntimeException

Module Contents

ConfigurationError(message: String!)

ConfigurationError(message: String!, @Nullable cause: Throwable?)

message

String

)

message

String

@Nullable

cause

Throwable

)

class ConfigurationErrors

Module Contents

static fun noErrors(): MutableList<

static fun singleError(message: String!): MutableList<

static fun singleError(message: String!, @Nullable cause: Throwable?): MutableList<

message

String

)

MutableList

message

String

@Nullable

cause

Throwable

)

MutableList

interface ConfigurationValidator

Module Contents

abstract fun validate(configuration:

)

MutableList

class DocumentPosition

Module Contents

class InvalidConfigurationPropertyTypeException : RuntimeException

Module Contents

class NoConfigurationPropertyException : RuntimeException

interface PropertyValidator<T : Any!>

Module Contents

open static fun <T : Any!> allInList(validator:

)

open static fun anyOf(vararg values: String!):

MutableList

open static fun anyOf(values: MutableCollection<String!>!):

String

open static fun anyOf(values: MutableCollection<String!>!, comparator: Comparator<String!>!):

String

open static fun anyOfIgnoreCase(vararg values: String!):

String

open static fun anyOfIgnoreCase(values: MutableCollection<String!>!):

String

open static fun <T : Any!> combine(first:

String

second

)

open static fun <T : Any!> combine(validators: MutableList<

)

open static fun inRange(from: Long, to: Long):

open static fun isPresent():

Number

Any

open static fun isURL():

abstract fun validate(key: String!, @Nullable position:

String

@Nullable

value

)

MutableList

fun defaultsKeySet(): MutableSet<String!>!

class Schema

Module Contents

fun defaultsKeySet(prefix: String!): MutableSet<String!>!

@Nullable fun description(key: String!): String?

fun getDefault(key: String!): Any!

@Nullable fun getDefaultBoolean(key: String!): Boolean?

@Nullable fun getDefaultDouble(key: String!): Double?

@Nullable fun getDefaultInteger(key: String!): Int?

@Nullable fun getDefaultList(key: String!): MutableList<Any!>?

@Nullable fun getDefaultListOfBoolean(key: String!): MutableList<Boolean!>?

@Nullable fun getDefaultListOfDouble(key: String!): MutableList<Double!>?

@Nullable fun getDefaultListOfInteger(key: String!): MutableList<Int!>?

@Nullable fun getDefaultListOfLong(key: String!): MutableList<Long!>?

@Nullable fun getDefaultListOfMap(key: String!): MutableList<MutableMap<String!, Any!>!>?

@Nullable fun getDefaultListOfString(key: String!): MutableList<String!>?

@Nullable fun getDefaultLong(key: String!): Long?

@Nullable fun getDefaultMap(key: String!): MutableMap<String!, Any!>?

@Nullable fun getDefaultString(key: String!): String?

fun getSubSection(name: String!):

fun getSubSectionPrefix(key: String!): String!

fun hasDefault(key: String!): Boolean

fun validate(configuration:

)

Stream

fun addBoolean(key: String!, @Nullable defaultValue: Boolean?, @Nullable description: String?, @Nullable validator:

class SchemaBuilder

Module Contents

Boolean

)

fun addDefault(key: String!, value: Any!):

fun addDouble(key: String!, @Nullable defaultValue: Double?, @Nullable description: String?, @Nullable validator:

Double

)

fun addInteger(key: String!, @Nullable defaultValue: Int?, @Nullable description: String?, @Nullable validator:

Int

)

fun addListOfBoolean(key: String!, @Nullable defaultValue: MutableList<Boolean!>?, @Nullable description: String?, @Nullable validator:

MutableList

Boolean

)

fun addListOfDouble(key: String!, @Nullable defaultValue: MutableList<Double!>?, @Nullable description: String?, @Nullable validator:

MutableList

Double

)

fun addListOfInteger(key: String!, @Nullable defaultValue: MutableList<Int!>?, @Nullable description: String?, @Nullable validator:

MutableList

Int

)

fun addListOfLong(key: String!, @Nullable defaultValue: MutableList<Long!>?, @Nullable description: String?, @Nullable validator:

MutableList

Long

)

fun addListOfMap(key: String!, @Nullable defaultValue: MutableList<MutableMap<String!, Any!>!>?, @Nullable description: String?, @Nullable validator:

MutableList

MutableMap

String

Any

)

fun addListOfString(key: String!, @Nullable defaultValue: MutableList<String!>?, @Nullable description: String?, @Nullable validator:

MutableList

String

)

fun addLong(key: String!, @Nullable defaultValue: Long?, @Nullable description: String?, @Nullable validator:

Long

)

fun addSection(key: String!, section:

)

fun addString(key: String!, @Nullable defaultValue: String?, @Nullable description: String?, @Nullable validator:

String

)

static fun create():

fun documentProperty(key: String!, description: String!):

fun toSchema():

fun validateConfiguration(validator:

ConfigurationValidator

)

fun validateProperty(key: String!, validator:

Any

)

package org.apache.tuweni.crypto

Module Contents

class Hash

Module Contents

static fun digestUsingAlgorithm(input: ByteArray!, alg: String!): ByteArray!

static fun digestUsingAlgorithm(input:

alg

String

)

static fun keccak256(input: ByteArray!): ByteArray!

static fun keccak256(input:

)

static fun keccak512(input: ByteArray!): ByteArray!

static fun keccak512(input:

)

static fun sha2_256(input: ByteArray!): ByteArray!

static fun sha2_256(input:

)

static fun sha2_512_256(input: ByteArray!): ByteArray!

static fun sha2_512_256(input:

)

static fun sha3_256(input: ByteArray!): ByteArray!

static fun sha3_256(input:

)

static fun sha3_512(input: ByteArray!): ByteArray!

static fun sha3_512(input:

)

class InvalidSEC256K1SecretKeyStoreException : RuntimeException

Module Contents

InvalidSEC256K1SecretKeyStoreException()

class SECP256K1

Module Contents

static fun calculateKeyAgreement(privKey: SecretKey!, theirPubKey: PublicKey!):

static fun deriveECDHKeyAgreement(srcPrivKey:

destPubKey

)

Module Contents

open static fun create(secretKey: SecretKey!, publicKey: PublicKey!): KeyPair!

open static fun fromSecretKey(secretKey: SecretKey!): KeyPair!

open static fun load(file: Path!): KeyPair!

open fun publicKey(): PublicKey!

open static fun random(): KeyPair!

open fun secretKey(): SecretKey!

static val CURVE: ECDomainParameters!

class Parameters

Module Contents

Parameters()

open fun asEcPoint(): ECPoint!

Module Contents

open static fun fromHexString(str: CharSequence!): PublicKey!

)

PublicKey

open static fun fromInteger(privateKey: BigInteger!): PublicKey!

open static fun fromSecretKey(secretKey: SecretKey!): PublicKey!

@Nullable open static fun recoverFromHashAndSignature(hash: ByteArray!, signature: Signature!): PublicKey?

@Nullable open static fun recoverFromHashAndSignature(hash:

@Nullable open static fun recoverFromSignature(data: ByteArray!, signature: Signature!): PublicKey?

signature

Signature

)

PublicKey

@Nullable open static fun recoverFromSignature(data:

signature

Signature

)

PublicKey

Module Contents

open fun destroy(): Unit

protected open fun finalize(): Unit

open static fun fromInteger(key: BigInteger!): SecretKey!

)

SecretKey

open static fun load(file: Path!): SecretKey!

static fun sign(data: ByteArray!, keyPair: KeyPair!): Signature!

static fun sign(data:

keyPair

KeyPair

)

Signature

Module Contents

open static fun create(v: Byte, r: BigInteger!, s: BigInteger!): Signature!

)

Signature

open fun isCanonical(): Boolean

open fun r(): BigInteger!

open fun s(): BigInteger!

static fun signHashed(hash: ByteArray!, keyPair: KeyPair!): Signature!

open fun v(): Byte

static fun signHashed(hash:

static fun verify(data: ByteArray!, signature: Signature!, publicKey: PublicKey!): Boolean

keyPair

KeyPair

)

Signature

static fun verify(data:

static fun verifyHashed(hash:

signature

Signature

publicKey

PublicKey

)

Boolean

static fun verifyHashed(hash: ByteArray!, signature: Signature!, publicKey: PublicKey!): Boolean

signature

Signature

publicKey

PublicKey

)

Boolean

package org.apache.tuweni.crypto.mikuli

Module Contents

class BLS12381

Module Contents

message

ByteArray

domain

Int

)

message

domain

Int

)

signature

message

ByteArray

domain

Int

)

Boolean

signature

message

domain

Int

)

Boolean

message

ByteArray

domain

Int

)

Boolean

message

static fun aggregate(keys: MutableList<

domain

Int

)

Boolean

Module Contents

Module Contents

)

)

fun toByteArray(): ByteArray!

class SecretKey

Module Contents

SecretKey

static fun aggregate(signatures: MutableList<

)

Module Contents

)

fun combine(signature:

)

static fun decode(bytes:

)

class SignatureAndPublicKey

Module Contents

static fun aggregate(sigAndPubKeys: MutableList<

)

fun combine(sigAndPubKey:

)

package org.apache.tuweni.crypto.sodium

Module Contents

class AES256GCM : AutoCloseable

Module Contents

nonce

Nonce

)

@Nullable fun decrypt(cipherText: ByteArray!, nonce: Nonce!): ByteArray?

data

nonce

Nonce

)

@Nullable fun decrypt(cipherText: ByteArray!, data: ByteArray!, nonce: Nonce!): ByteArray?

key

Key

nonce

Nonce

)

@Nullable static fun decrypt(cipherText: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

data

key

Key

nonce

Nonce

)

@Nullable static fun decrypt(cipherText: ByteArray!, data: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

mac

nonce

Nonce

)

@Nullable fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, nonce: Nonce!): ByteArray?

mac

data

nonce

Nonce

)

@Nullable fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, data: ByteArray!, nonce: Nonce!): ByteArray?

mac

key

Key

nonce

Nonce

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

mac

data

key

Key

nonce

Nonce

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, data: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

nonce

Nonce

)

fun encrypt(message: ByteArray!, nonce: Nonce!): ByteArray!

data

nonce

Nonce

)

fun encrypt(message: ByteArray!, data: ByteArray!, nonce: Nonce!): ByteArray!

key

Key

nonce

Nonce

)

static fun encrypt(message: ByteArray!, key: Key!, nonce: Nonce!): ByteArray!

data

key

Key

nonce

Nonce

)

static fun encrypt(message: ByteArray!, data: ByteArray!, key: Key!, nonce: Nonce!): ByteArray!

nonce

Nonce

)

fun encryptDetached(message: ByteArray!, nonce: Nonce!):

data

nonce

Nonce

)

fun encryptDetached(message: ByteArray!, data: ByteArray!, nonce: Nonce!):

key

Key

nonce

Nonce

)

static fun encryptDetached(message: ByteArray!, key: Key!, nonce: Nonce!):

data

key

Key

nonce

Nonce

)

static fun encryptDetached(message: ByteArray!, data: ByteArray!, key: Key!, nonce: Nonce!):

static fun forKey(key: Key!):

AES256GCM

Module Contents

)

Key

Module Contents

)

Nonce

class Allocated : Destroyable

Module Contents

)

class Auth

Module Contents

static fun auth(input:

key

Key

)

static fun auth(input: ByteArray!, key: Key!): ByteArray!

Module Contents

)

Key

static fun verify(tag:

input

static fun verify(tag: ByteArray!, input: ByteArray!, key: Key!): Boolean

key

Key

)

Boolean

class Box : AutoCloseable

Module Contents

nonce

Nonce

)

@Nullable fun decrypt(cipherText: ByteArray!, nonce: Nonce!): ByteArray?

sender

PublicKey

receiver

SecretKey

nonce

Nonce

)

@Nullable static fun decrypt(cipherText: ByteArray!, sender: PublicKey!, receiver: SecretKey!, nonce: Nonce!): ByteArray?

mac

nonce

Nonce

)

@Nullable fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, nonce: Nonce!): ByteArray?

mac

sender

PublicKey

receiver

SecretKey

nonce

Nonce

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, sender: PublicKey!, receiver: SecretKey!, nonce: Nonce!): ByteArray?

@Nullable static fun decryptSealed(cipherText:

sender

PublicKey

receiver

SecretKey

)

@Nullable static fun decryptSealed(cipherText: ByteArray!, sender: PublicKey!, receiver: SecretKey!): ByteArray?

nonce

Nonce

)

fun encrypt(message: ByteArray!, nonce: Nonce!): ByteArray!

receiver

PublicKey

sender

SecretKey

nonce

Nonce

)

static fun encrypt(message: ByteArray!, receiver: PublicKey!, sender: SecretKey!, nonce: Nonce!): ByteArray!

nonce

Nonce

)

fun encryptDetached(message: ByteArray!, nonce: Nonce!):

receiver

PublicKey

sender

SecretKey

nonce

Nonce

)

static fun encryptDetached(message: ByteArray!, receiver: PublicKey!, sender: SecretKey!, nonce: Nonce!):

static fun encryptSealed(message:

receiver

PublicKey

)

static fun encryptSealed(message: ByteArray!, receiver: PublicKey!): ByteArray!

static fun forKeys(receiver: PublicKey!, sender: SecretKey!):

Box

KeyPair(publicKey: PublicKey!, secretKey: SecretKey!)

Module Contents

static fun forSecretKey(secretKey: SecretKey!): KeyPair!

static fun forSignatureKeyPair(keyPair: KeyPair!): KeyPair!

Module Contents

)

Nonce

Module Contents

static fun forSignaturePublicKey(publicKey: PublicKey!): PublicKey!

static fun fromBytes(bytes: ByteArray!): PublicKey!

)

PublicKey

Module Contents

static fun forSignatureSecretKey(secretKey: SecretKey!): SecretKey!

static fun fromBytes(bytes: ByteArray!): SecretKey!

)

SecretKey

Module Contents

)

Seed

class Concatenate

Module Contents

Concatenate()

)

fun add(key: Secret!):

fun concatenate():

interface DetachedEncryptionResult

Module Contents

abstract fun cipherText():

abstract fun cipherTextArray(): ByteArray!

abstract fun mac():

abstract fun macArray(): ByteArray!

class DiffieHelman

Module Contents

DiffieHelman()

KeyPair(publicKey: PublicKey!, secretKey: SecretKey!)

Module Contents

static fun forSecretKey(secretKey: SecretKey!): KeyPair!

Module Contents

static fun forBoxPublicKey(publicKey: PublicKey!): PublicKey!

static fun forSignaturePublicKey(publicKey: PublicKey!): PublicKey!

static fun fromBytes(bytes: ByteArray!): PublicKey!

)

PublicKey

class Secret : Destroyable

Module Contents

static fun forKeys(secretKey: SecretKey!, publicKey: PublicKey!): Secret!

static fun fromBytes(bytes: ByteArray!): Secret!

)

Secret

Module Contents

static fun forBoxSecretKey(secretKey: SecretKey!): SecretKey!

static fun forSignatureSecretKey(secretKey: SecretKey!): SecretKey!

static fun fromBytes(bytes: ByteArray!): SecretKey!

)

SecretKey

class GenericHash

Module Contents

GenericHash()

Module Contents

static fun hash(hashLength: Int, input: Input!): Hash!

static fun hash(hashLength: Int, input: Input!, key: Key!): Hash!

Module Contents

)

Input

)

Input

Module Contents

)

Key

)

Key

class HMACSHA256

Module Contents

key

Key

)

static fun authenticate(message: ByteArray!, key: Key!): ByteArray!

Module Contents

)

Key

static fun verify(authenticator: ByteArray!, in: ByteArray!, key: Key!): Boolean

key

Key

)

Boolean

class HMACSHA512

Module Contents

key

Key

)

static fun authenticate(message: ByteArray!, key: Key!): ByteArray!

Module Contents

)

Key

static fun verify(authenticator: ByteArray!, in: ByteArray!, key: Key!): Boolean

key

Key

)

Boolean

class HMACSHA512256

Module Contents

key

Key

)

static fun authenticate(message: ByteArray!, key: Key!): ByteArray!

Module Contents

)

Key

static fun verify(authenticator: ByteArray!, in: ByteArray!, key: Key!): Boolean

key

Key

)

Boolean

class KeyDerivation

Module Contents

KeyDerivation()

static fun contextLength(): Int

class MasterKey : Destroyable

Module Contents

fun deriveKey(length: Int, subkeyId: Long, context: ByteArray!):

fun deriveKey(length: Int, subkeyId: Long, context: String!):

fun deriveKeyArray(length: Int, subkeyId: Long, context: ByteArray!): ByteArray!

fun deriveKeyArray(length: Int, subkeyId: Long, context: String!): ByteArray!

static fun fromBytes(bytes: ByteArray!): MasterKey!

)

MasterKey

static fun random(): MasterKey!

static fun maxSubKeyLength(): Int

static fun minSubKeyLength(): Int

class KeyExchange

Module Contents

KeyExchange()

static fun client(clientKeys: KeyPair!, serverKey: PublicKey!): SessionKeyPair!

KeyPair(publicKey: PublicKey!, secretKey: SecretKey!)

Module Contents

static fun forSecretKey(secretKey: SecretKey!): KeyPair!

Module Contents

static fun fromBytes(bytes: ByteArray!): PublicKey!

)

PublicKey

Module Contents

static fun fromBytes(bytes: ByteArray!): SecretKey!

)

SecretKey

Module Contents

)

Seed

static fun server(serverKeys: KeyPair!, clientKey: PublicKey!): SessionKeyPair!

class SessionKey : Destroyable

Module Contents

static fun fromBytes(bytes: ByteArray!): SessionKey!

)

SessionKey

SessionKeyPair(rxKey: SessionKey!, txKey: SessionKey!)

class SessionKeyPair

Module Contents

abstract fun _sodium_alloc_init(): Int

fun rx(): SessionKey!

fun tx(): SessionKey!

interface LibSodium

Module Contents

abstract fun _sodium_runtime_get_cpu_features(): Int

abstract fun buf(buf: ByteArray!, size: Long): Unit

abstract fun close(): Int

abstract fun crypto_aead_aes256gcm_abytes(): Long

abstract fun crypto_aead_aes256gcm_beforenm(ctx_: Pointer!, k: Pointer!): Int

abstract fun crypto_aead_aes256gcm_decrypt(m: ByteArray!, mlen_p: LongLongByReference!, nsec: Pointer!, c: ByteArray!, clen: Long, ad: ByteArray!, adlen: Long, npub: Pointer!, k: Pointer!): Int

abstract fun crypto_aead_aes256gcm_decrypt_detached(m: ByteArray!, nsec: Pointer!, c: ByteArray!, clen: Long, mac: ByteArray!, ad: ByteArray!, adlen: Long, npub: Pointer!, k: Pointer!): Int

abstract fun crypto_aead_aes256gcm_encrypt(c: ByteArray!, clen_p: LongLongByReference!, m: ByteArray!, mlen: Long, ad: ByteArray!, adlen: Long, nsec: Pointer!, npub: Pointer!, k: Pointer!): Int

abstract fun crypto_aead_aes256gcm_is_available(): Int

abstract fun crypto_aead_aes256gcm_keybytes(): Long

abstract fun crypto_aead_aes256gcm_keygen(k: Pointer!): Unit

abstract fun crypto_aead_aes256gcm_messagebytes_max(): Long

abstract fun crypto_aead_aes256gcm_npubbytes(): Long

abstract fun crypto_aead_aes256gcm_nsecbytes(): Long

abstract fun crypto_aead_aes256gcm_statebytes(): Long

abstract fun crypto_aead_chacha20poly1305_abytes(): Long

abstract fun crypto_aead_chacha20poly1305_ietf_abytes(): Long

abstract fun crypto_aead_chacha20poly1305_ietf_keybytes(): Long

abstract fun crypto_aead_chacha20poly1305_ietf_keygen(k: ByteArray!): Unit

abstract fun crypto_aead_chacha20poly1305_ietf_messagebytes_max(): Long

abstract fun crypto_aead_chacha20poly1305_ietf_npubbytes(): Long

abstract fun crypto_aead_chacha20poly1305_ietf_nsecbytes(): Long

abstract fun crypto_aead_chacha20poly1305_keybytes(): Long

abstract fun crypto_aead_chacha20poly1305_keygen(k: ByteArray!): Unit

abstract fun crypto_aead_chacha20poly1305_messagebytes_max(): Long

abstract fun crypto_aead_chacha20poly1305_npubbytes(): Long

abstract fun crypto_aead_chacha20poly1305_nsecbytes(): Long

abstract fun crypto_aead_xchacha20poly1305_ietf_abytes(): Long

abstract fun crypto_aead_xchacha20poly1305_ietf_keybytes(): Long

abstract fun crypto_aead_xchacha20poly1305_ietf_keygen(k: Pointer!): Unit

abstract fun crypto_aead_xchacha20poly1305_ietf_messagebytes_max(): Long

abstract fun crypto_aead_xchacha20poly1305_ietf_npubbytes(): Long

abstract fun crypto_aead_xchacha20poly1305_ietf_nsecbytes(): Long

abstract fun crypto_auth(out: ByteArray!, in: ByteArray!, inlen: Long, k: Pointer!): Int

abstract fun crypto_auth_bytes(): Long

abstract fun crypto_auth_hmacsha256(out: ByteArray!, in: ByteArray!, inlen: Long, k: Pointer!): Int

abstract fun crypto_auth_hmacsha256_bytes(): Long

abstract fun crypto_auth_hmacsha256_final(state: Pointer!, out: ByteArray!): Int

abstract fun crypto_auth_hmacsha256_init(state: Pointer!, key: ByteArray!, keylen: Long): Int

abstract fun crypto_auth_hmacsha256_keybytes(): Long

abstract fun crypto_auth_hmacsha256_keygen(k: ByteArray!): Unit

abstract fun crypto_auth_hmacsha256_statebytes(): Long

abstract fun crypto_auth_hmacsha256_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_auth_hmacsha256_verify(h: ByteArray!, in: ByteArray!, inlen: Long, k: Pointer!): Int

abstract fun crypto_auth_hmacsha512(out: ByteArray!, in: ByteArray!, inlen: Long, k: Pointer!): Int

abstract fun crypto_auth_hmacsha512256(out: ByteArray!, in: ByteArray!, inlen: Long, k: Pointer!): Int

abstract fun crypto_auth_hmacsha512256_bytes(): Long

abstract fun crypto_auth_hmacsha512256_final(state: Pointer!, out: ByteArray!): Int

abstract fun crypto_auth_hmacsha512256_init(state: Pointer!, key: ByteArray!, keylen: Long): Int

abstract fun crypto_auth_hmacsha512256_keybytes(): Long

abstract fun crypto_auth_hmacsha512256_keygen(k: ByteArray!): Unit

abstract fun crypto_auth_hmacsha512256_statebytes(): Long

abstract fun crypto_auth_hmacsha512256_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_auth_hmacsha512256_verify(h: ByteArray!, in: ByteArray!, inlen: Long, k: Pointer!): Int

abstract fun crypto_auth_hmacsha512_bytes(): Long

abstract fun crypto_auth_hmacsha512_final(state: Pointer!, out: ByteArray!): Int

abstract fun crypto_auth_hmacsha512_init(state: Pointer!, key: ByteArray!, keylen: Long): Int

abstract fun crypto_auth_hmacsha512_keybytes(): Long

abstract fun crypto_auth_hmacsha512_keygen(k: ByteArray!): Unit

abstract fun crypto_auth_hmacsha512_statebytes(): Long

abstract fun crypto_auth_hmacsha512_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_auth_hmacsha512_verify(h: ByteArray!, in: ByteArray!, inlen: Long, k: Pointer!): Int

abstract fun crypto_auth_keybytes(): Long

abstract fun crypto_auth_keygen(k: Pointer!): Unit

abstract fun crypto_auth_primitive(): String!

abstract fun crypto_auth_verify(h: ByteArray!, in: ByteArray!, inlen: Long, k: Pointer!): Int

abstract fun crypto_box(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_afternm(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: Pointer!): Int

abstract fun crypto_box_beforenm(k: Pointer!, pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_box_beforenmbytes(): Long

abstract fun crypto_box_boxzerobytes(): Long

abstract fun crypto_box_curve25519xchacha20poly1305_beforenm(k: Pointer!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_beforenmbytes(): Long

abstract fun crypto_box_curve25519xchacha20poly1305_detached(c: ByteArray!, mac: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_detached_afternm(c: ByteArray!, mac: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: Pointer!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_easy(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_easy_afternm(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: Pointer!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_keypair(pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_macbytes(): Long

abstract fun crypto_box_curve25519xchacha20poly1305_messagebytes_max(): Long

abstract fun crypto_box_curve25519xchacha20poly1305_noncebytes(): Long

abstract fun crypto_box_curve25519xchacha20poly1305_open_detached(m: ByteArray!, c: ByteArray!, mac: ByteArray!, clen: Long, n: ByteArray!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_open_detached_afternm(m: ByteArray!, c: ByteArray!, mac: ByteArray!, clen: Long, n: ByteArray!, k: Pointer!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_open_easy(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_open_easy_afternm(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, k: Pointer!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_publickeybytes(): Long

abstract fun crypto_box_curve25519xchacha20poly1305_seal(c: ByteArray!, m: ByteArray!, mlen: Long, pk: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_seal_open(m: ByteArray!, c: ByteArray!, clen: Long, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_sealbytes(): Long

abstract fun crypto_box_curve25519xchacha20poly1305_secretkeybytes(): Long

abstract fun crypto_box_curve25519xchacha20poly1305_seed_keypair(pk: ByteArray!, sk: ByteArray!, seed: ByteArray!): Int

abstract fun crypto_box_curve25519xchacha20poly1305_seedbytes(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xsalsa20poly1305_afternm(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: Pointer!): Int

abstract fun crypto_box_curve25519xsalsa20poly1305_beforenm(k: Pointer!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xsalsa20poly1305_beforenmbytes(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305_boxzerobytes(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305_keypair(pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xsalsa20poly1305_macbytes(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305_messagebytes_max(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305_noncebytes(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305_open(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_curve25519xsalsa20poly1305_open_afternm(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, k: Pointer!): Int

abstract fun crypto_box_curve25519xsalsa20poly1305_publickeybytes(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305_secretkeybytes(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305_seed_keypair(pk: ByteArray!, sk: ByteArray!, seed: ByteArray!): Int

abstract fun crypto_box_curve25519xsalsa20poly1305_seedbytes(): Long

abstract fun crypto_box_curve25519xsalsa20poly1305_zerobytes(): Long

abstract fun crypto_box_detached(c: ByteArray!, mac: ByteArray!, m: ByteArray!, mlen: Long, n: Pointer!, pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_box_detached_afternm(c: ByteArray!, mac: ByteArray!, m: ByteArray!, mlen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_box_easy(c: ByteArray!, m: ByteArray!, mlen: Long, n: Pointer!, pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_box_easy_afternm(c: ByteArray!, m: ByteArray!, mlen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_box_keypair(pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_box_macbytes(): Long

abstract fun crypto_box_messagebytes_max(): Long

abstract fun crypto_box_noncebytes(): Long

abstract fun crypto_box_open(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_box_open_afternm(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, k: Pointer!): Int

abstract fun crypto_box_open_detached(m: ByteArray!, c: ByteArray!, mac: ByteArray!, clen: Long, n: Pointer!, pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_box_open_detached_afternm(m: ByteArray!, c: ByteArray!, mac: ByteArray!, clen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_box_open_easy(m: ByteArray!, c: ByteArray!, clen: Long, n: Pointer!, pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_box_open_easy_afternm(m: ByteArray!, c: ByteArray!, clen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_box_primitive(): String!

abstract fun crypto_box_publickeybytes(): Long

abstract fun crypto_box_seal(c: ByteArray!, m: ByteArray!, mlen: Long, pk: Pointer!): Int

abstract fun crypto_box_seal_open(m: ByteArray!, c: ByteArray!, clen: Long, pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_box_sealbytes(): Long

abstract fun crypto_box_secretkeybytes(): Long

abstract fun crypto_box_seed_keypair(pk: Pointer!, sk: Pointer!, seed: Pointer!): Int

abstract fun crypto_box_seedbytes(): Long

abstract fun crypto_box_zerobytes(): Long

abstract fun crypto_core_ed25519_add(r: ByteArray!, p: ByteArray!, q: ByteArray!): Int

abstract fun crypto_core_ed25519_bytes(): Long

abstract fun crypto_core_ed25519_from_hash(p: ByteArray!, h: ByteArray!): Int

abstract fun crypto_core_ed25519_from_uniform(p: ByteArray!, r: ByteArray!): Int

abstract fun crypto_core_ed25519_hashbytes(): Long

abstract fun crypto_core_ed25519_is_valid_point(p: ByteArray!): Int

abstract fun crypto_core_ed25519_nonreducedscalarbytes(): Long

abstract fun crypto_core_ed25519_random(p: ByteArray!): Unit

abstract fun crypto_core_ed25519_scalar_add(z: ByteArray!, x: ByteArray!, y: ByteArray!): Unit

abstract fun crypto_core_ed25519_scalar_complement(comp: ByteArray!, s: ByteArray!): Unit

abstract fun crypto_core_ed25519_scalar_invert(recip: ByteArray!, s: ByteArray!): Int

abstract fun crypto_core_ed25519_scalar_mul(z: ByteArray!, x: ByteArray!, y: ByteArray!): Unit

abstract fun crypto_core_ed25519_scalar_negate(neg: ByteArray!, s: ByteArray!): Unit

abstract fun crypto_core_ed25519_scalar_random(r: ByteArray!): Unit

abstract fun crypto_core_ed25519_scalar_reduce(r: ByteArray!, s: ByteArray!): Unit

abstract fun crypto_core_ed25519_scalar_sub(z: ByteArray!, x: ByteArray!, y: ByteArray!): Unit

abstract fun crypto_core_ed25519_scalarbytes(): Long

abstract fun crypto_core_ed25519_sub(r: ByteArray!, p: ByteArray!, q: ByteArray!): Int

abstract fun crypto_core_ed25519_uniformbytes(): Long

abstract fun crypto_core_hchacha20(out: ByteArray!, in: ByteArray!, k: ByteArray!, c: ByteArray!): Int

abstract fun crypto_core_hchacha20_constbytes(): Long

abstract fun crypto_core_hchacha20_inputbytes(): Long

abstract fun crypto_core_hchacha20_keybytes(): Long

abstract fun crypto_core_hchacha20_outputbytes(): Long

abstract fun crypto_core_hsalsa20(out: ByteArray!, in: ByteArray!, k: ByteArray!, c: ByteArray!): Int

abstract fun crypto_core_hsalsa20_constbytes(): Long

abstract fun crypto_core_hsalsa20_inputbytes(): Long

abstract fun crypto_core_hsalsa20_keybytes(): Long

abstract fun crypto_core_hsalsa20_outputbytes(): Long

abstract fun crypto_core_ristretto255_add(r: ByteArray!, p: ByteArray!, q: ByteArray!): Int

abstract fun crypto_core_ristretto255_bytes(): Long

abstract fun crypto_core_ristretto255_from_hash(p: ByteArray!, r: ByteArray!): Int

abstract fun crypto_core_ristretto255_hashbytes(): Long

abstract fun crypto_core_ristretto255_is_valid_point(p: ByteArray!): Int

abstract fun crypto_core_ristretto255_nonreducedscalarbytes(): Long

abstract fun crypto_core_ristretto255_random(p: ByteArray!): Unit

abstract fun crypto_core_ristretto255_scalar_add(z: ByteArray!, x: ByteArray!, y: ByteArray!): Unit

abstract fun crypto_core_ristretto255_scalar_complement(comp: ByteArray!, s: ByteArray!): Unit

abstract fun crypto_core_ristretto255_scalar_invert(recip: ByteArray!, s: ByteArray!): Int

abstract fun crypto_core_ristretto255_scalar_mul(z: ByteArray!, x: ByteArray!, y: ByteArray!): Unit

abstract fun crypto_core_ristretto255_scalar_negate(neg: ByteArray!, s: ByteArray!): Unit

abstract fun crypto_core_ristretto255_scalar_random(r: ByteArray!): Unit

abstract fun crypto_core_ristretto255_scalar_reduce(r: ByteArray!, s: ByteArray!): Unit

abstract fun crypto_core_ristretto255_scalar_sub(z: ByteArray!, x: ByteArray!, y: ByteArray!): Unit

abstract fun crypto_core_ristretto255_scalarbytes(): Long

abstract fun crypto_core_ristretto255_sub(r: ByteArray!, p: ByteArray!, q: ByteArray!): Int

abstract fun crypto_core_salsa20(out: ByteArray!, in: ByteArray!, k: ByteArray!, c: ByteArray!): Int

abstract fun crypto_core_salsa2012(out: ByteArray!, in: ByteArray!, k: ByteArray!, c: ByteArray!): Int

abstract fun crypto_core_salsa2012_constbytes(): Long

abstract fun crypto_core_salsa2012_inputbytes(): Long

abstract fun crypto_core_salsa2012_keybytes(): Long

abstract fun crypto_core_salsa2012_outputbytes(): Long

abstract fun crypto_core_salsa208(out: ByteArray!, in: ByteArray!, k: ByteArray!, c: ByteArray!): Int

abstract fun crypto_core_salsa208_constbytes(): Long

abstract fun crypto_core_salsa208_inputbytes(): Long

abstract fun crypto_core_salsa208_keybytes(): Long

abstract fun crypto_core_salsa208_outputbytes(): Long

abstract fun crypto_core_salsa20_constbytes(): Long

abstract fun crypto_core_salsa20_inputbytes(): Long

abstract fun crypto_core_salsa20_keybytes(): Long

abstract fun crypto_core_salsa20_outputbytes(): Long

abstract fun crypto_generichash(out: Pointer!, outlen: Long, in: Pointer!, inlen: Long, key: Pointer!, keylen: Long): Int

abstract fun crypto_generichash_blake2b(out: ByteArray!, outlen: Long, in: ByteArray!, inlen: Long, key: ByteArray!, keylen: Long): Int

abstract fun crypto_generichash_blake2b_bytes(): Long

abstract fun crypto_generichash_blake2b_bytes_max(): Long

abstract fun crypto_generichash_blake2b_bytes_min(): Long

abstract fun crypto_generichash_blake2b_final(state: Pointer!, out: ByteArray!, outlen: Long): Int

abstract fun crypto_generichash_blake2b_init(state: Pointer!, key: ByteArray!, keylen: Long, outlen: Long): Int

abstract fun crypto_generichash_blake2b_init_salt_personal(state: Pointer!, key: ByteArray!, keylen: Long, outlen: Long, salt: ByteArray!, personal: ByteArray!): Int

abstract fun crypto_generichash_blake2b_keybytes(): Long

abstract fun crypto_generichash_blake2b_keybytes_max(): Long

abstract fun crypto_generichash_blake2b_keybytes_min(): Long

abstract fun crypto_generichash_blake2b_keygen(k: ByteArray!): Unit

abstract fun crypto_generichash_blake2b_personalbytes(): Long

abstract fun crypto_generichash_blake2b_salt_personal(out: ByteArray!, outlen: Long, in: ByteArray!, inlen: Long, key: ByteArray!, keylen: Long, salt: ByteArray!, personal: ByteArray!): Int

abstract fun crypto_generichash_blake2b_saltbytes(): Long

abstract fun crypto_generichash_blake2b_statebytes(): Long

abstract fun crypto_generichash_blake2b_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_generichash_bytes(): Long

abstract fun crypto_generichash_bytes_max(): Long

abstract fun crypto_generichash_bytes_min(): Long

abstract fun crypto_generichash_final(state: Pointer!, out: ByteArray!, outlen: Long): Int

abstract fun crypto_generichash_init(state: Pointer!, key: ByteArray!, keylen: Long, outlen: Long): Int

abstract fun crypto_generichash_keybytes(): Long

abstract fun crypto_generichash_keybytes_max(): Long

abstract fun crypto_generichash_keybytes_min(): Long

abstract fun crypto_generichash_keygen(k: ByteArray!): Unit

abstract fun crypto_generichash_primitive(): String!

abstract fun crypto_generichash_statebytes(): Long

abstract fun crypto_generichash_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_hash(out: ByteArray!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_hash_bytes(): Long

abstract fun crypto_hash_primitive(): String!

abstract fun crypto_hash_sha256(out: ByteArray!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_hash_sha256(out: Pointer!, in: Pointer!, inlen: Long): Int

abstract fun crypto_hash_sha256_bytes(): Long

abstract fun crypto_hash_sha256_final(state: Pointer!, out: ByteArray!): Int

abstract fun crypto_hash_sha256_init(state: Pointer!): Int

abstract fun crypto_hash_sha256_statebytes(): Long

abstract fun crypto_hash_sha256_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_hash_sha512(out: ByteArray!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_hash_sha512_bytes(): Long

abstract fun crypto_hash_sha512_final(state: Pointer!, out: ByteArray!): Int

abstract fun crypto_hash_sha512_init(state: Pointer!): Int

abstract fun crypto_hash_sha512_statebytes(): Long

abstract fun crypto_hash_sha512_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_kdf_blake2b_bytes_max(): Long

abstract fun crypto_kdf_blake2b_bytes_min(): Long

abstract fun crypto_kdf_blake2b_contextbytes(): Long

abstract fun crypto_kdf_blake2b_derive_from_key(subkey: ByteArray!, subkey_len: Long, subkey_id: Long, ctx: ByteArray!, key: Pointer!): Int

abstract fun crypto_kdf_blake2b_keybytes(): Long

abstract fun crypto_kdf_bytes_max(): Long

abstract fun crypto_kdf_bytes_min(): Long

abstract fun crypto_kdf_contextbytes(): Long

abstract fun crypto_kdf_derive_from_key(subkey: ByteArray!, subkey_len: Long, subkey_id: Long, ctx: ByteArray!, key: Pointer!): Int

abstract fun crypto_kdf_keybytes(): Long

abstract fun crypto_kdf_keygen(k: Pointer!): Unit

abstract fun crypto_kdf_primitive(): String!

abstract fun crypto_kx_client_session_keys(rx: Pointer!, tx: Pointer!, client_pk: Pointer!, client_sk: Pointer!, server_pk: Pointer!): Int

abstract fun crypto_kx_keypair(pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_kx_primitive(): String!

abstract fun crypto_kx_publickeybytes(): Long

abstract fun crypto_kx_secretkeybytes(): Long

abstract fun crypto_kx_seed_keypair(pk: Pointer!, sk: Pointer!, seed: Pointer!): Int

abstract fun crypto_kx_seedbytes(): Long

abstract fun crypto_kx_server_session_keys(rx: Pointer!, tx: Pointer!, server_pk: Pointer!, server_sk: Pointer!, client_pk: Pointer!): Int

abstract fun crypto_kx_sessionkeybytes(): Long

abstract fun crypto_onetimeauth(out: ByteArray!, in: ByteArray!, inlen: Long, k: ByteArray!): Int

abstract fun crypto_onetimeauth_bytes(): Long

abstract fun crypto_onetimeauth_final(state: Pointer!, out: ByteArray!): Int

abstract fun crypto_onetimeauth_init(state: Pointer!, key: ByteArray!): Int

abstract fun crypto_onetimeauth_keybytes(): Long

abstract fun crypto_onetimeauth_keygen(k: ByteArray!): Unit

abstract fun crypto_onetimeauth_poly1305(out: ByteArray!, in: ByteArray!, inlen: Long, k: ByteArray!): Int

abstract fun crypto_onetimeauth_poly1305_bytes(): Long

abstract fun crypto_onetimeauth_poly1305_final(state: Pointer!, out: ByteArray!): Int

abstract fun crypto_onetimeauth_poly1305_init(state: Pointer!, key: ByteArray!): Int

abstract fun crypto_onetimeauth_poly1305_keybytes(): Long

abstract fun crypto_onetimeauth_poly1305_keygen(k: ByteArray!): Unit

abstract fun crypto_onetimeauth_poly1305_statebytes(): Long

abstract fun crypto_onetimeauth_poly1305_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_onetimeauth_poly1305_verify(h: ByteArray!, in: ByteArray!, inlen: Long, k: ByteArray!): Int

abstract fun crypto_onetimeauth_primitive(): String!

abstract fun crypto_onetimeauth_statebytes(): Long

abstract fun crypto_onetimeauth_update(state: Pointer!, in: ByteArray!, inlen: Long): Int

abstract fun crypto_onetimeauth_verify(h: ByteArray!, in: ByteArray!, inlen: Long, k: ByteArray!): Int

abstract fun crypto_pwhash(out: ByteArray!, outlen: Long, passwd: ByteArray!, passwdlen: Long, salt: Pointer!, opslimit: Long, memlimit: Long, alg: Int): Int

abstract fun crypto_pwhash_alg_argon2i13(): Int

abstract fun crypto_pwhash_alg_argon2id13(): Int

abstract fun crypto_pwhash_alg_default(): Int

abstract fun crypto_pwhash_argon2i(out: ByteArray!, outlen: Long, passwd: ByteArray!, passwdlen: Long, salt: ByteArray!, opslimit: Long, memlimit: Long, alg: Int): Int

abstract fun crypto_pwhash_argon2i_alg_argon2i13(): Int

abstract fun crypto_pwhash_argon2i_bytes_max(): Long

abstract fun crypto_pwhash_argon2i_bytes_min(): Long

abstract fun crypto_pwhash_argon2i_memlimit_interactive(): Long

abstract fun crypto_pwhash_argon2i_memlimit_max(): Long

abstract fun crypto_pwhash_argon2i_memlimit_min(): Long

abstract fun crypto_pwhash_argon2i_memlimit_moderate(): Long

abstract fun crypto_pwhash_argon2i_memlimit_sensitive(): Long

abstract fun crypto_pwhash_argon2i_opslimit_interactive(): Long

abstract fun crypto_pwhash_argon2i_opslimit_max(): Long

abstract fun crypto_pwhash_argon2i_opslimit_min(): Long

abstract fun crypto_pwhash_argon2i_opslimit_moderate(): Long

abstract fun crypto_pwhash_argon2i_opslimit_sensitive(): Long

abstract fun crypto_pwhash_argon2i_passwd_max(): Long

abstract fun crypto_pwhash_argon2i_passwd_min(): Long

abstract fun crypto_pwhash_argon2i_saltbytes(): Long

abstract fun crypto_pwhash_argon2i_str(out: ByteArray!, passwd: ByteArray!, passwdlen: Long, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_argon2i_str_needs_rehash(str: ByteArray!, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_argon2i_str_verify(str: ByteArray!, passwd: ByteArray!, passwdlen: Long): Int

abstract fun crypto_pwhash_argon2i_strbytes(): Long

abstract fun crypto_pwhash_argon2i_strprefix(): String!

abstract fun crypto_pwhash_argon2id(out: ByteArray!, outlen: Long, passwd: ByteArray!, passwdlen: Long, salt: ByteArray!, opslimit: Long, memlimit: Long, alg: Int): Int

abstract fun crypto_pwhash_argon2id_alg_argon2id13(): Int

abstract fun crypto_pwhash_argon2id_bytes_max(): Long

abstract fun crypto_pwhash_argon2id_bytes_min(): Long

abstract fun crypto_pwhash_argon2id_memlimit_interactive(): Long

abstract fun crypto_pwhash_argon2id_memlimit_max(): Long

abstract fun crypto_pwhash_argon2id_memlimit_min(): Long

abstract fun crypto_pwhash_argon2id_memlimit_moderate(): Long

abstract fun crypto_pwhash_argon2id_memlimit_sensitive(): Long

abstract fun crypto_pwhash_argon2id_opslimit_interactive(): Long

abstract fun crypto_pwhash_argon2id_opslimit_max(): Long

abstract fun crypto_pwhash_argon2id_opslimit_min(): Long

abstract fun crypto_pwhash_argon2id_opslimit_moderate(): Long

abstract fun crypto_pwhash_argon2id_opslimit_sensitive(): Long

abstract fun crypto_pwhash_argon2id_passwd_max(): Long

abstract fun crypto_pwhash_argon2id_passwd_min(): Long

abstract fun crypto_pwhash_argon2id_saltbytes(): Long

abstract fun crypto_pwhash_argon2id_str(out: ByteArray!, passwd: ByteArray!, passwdlen: Long, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_argon2id_str_needs_rehash(str: ByteArray!, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_argon2id_str_verify(str: ByteArray!, passwd: ByteArray!, passwdlen: Long): Int

abstract fun crypto_pwhash_argon2id_strbytes(): Long

abstract fun crypto_pwhash_argon2id_strprefix(): String!

abstract fun crypto_pwhash_bytes_max(): Long

abstract fun crypto_pwhash_bytes_min(): Long

abstract fun crypto_pwhash_memlimit_interactive(): Long

abstract fun crypto_pwhash_memlimit_max(): Long

abstract fun crypto_pwhash_memlimit_min(): Long

abstract fun crypto_pwhash_memlimit_moderate(): Long

abstract fun crypto_pwhash_memlimit_sensitive(): Long

abstract fun crypto_pwhash_opslimit_interactive(): Long

abstract fun crypto_pwhash_opslimit_max(): Long

abstract fun crypto_pwhash_opslimit_min(): Long

abstract fun crypto_pwhash_opslimit_moderate(): Long

abstract fun crypto_pwhash_opslimit_sensitive(): Long

abstract fun crypto_pwhash_passwd_max(): Long

abstract fun crypto_pwhash_passwd_min(): Long

abstract fun crypto_pwhash_primitive(): String!

abstract fun crypto_pwhash_saltbytes(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256(out: ByteArray!, outlen: Long, passwd: ByteArray!, passwdlen: Long, salt: ByteArray!, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_scryptsalsa208sha256_bytes_max(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_bytes_min(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_ll(passwd: ByteArray!, passwdlen: Long, salt: ByteArray!, saltlen: Long, N: Long, r: Int, p: Int, buf: ByteArray!, buflen: Long): Int

abstract fun crypto_pwhash_scryptsalsa208sha256_memlimit_interactive(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_memlimit_max(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_memlimit_min(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_opslimit_interactive(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_opslimit_max(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_opslimit_min(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_opslimit_sensitive(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_passwd_max(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_passwd_min(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_saltbytes(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_str(out: ByteArray!, passwd: ByteArray!, passwdlen: Long, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_scryptsalsa208sha256_str_needs_rehash(str: ByteArray!, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_scryptsalsa208sha256_str_verify(str: ByteArray!, passwd: ByteArray!, passwdlen: Long): Int

abstract fun crypto_pwhash_scryptsalsa208sha256_strbytes(): Long

abstract fun crypto_pwhash_scryptsalsa208sha256_strprefix(): String!

abstract fun crypto_pwhash_str(out: ByteArray!, passwd: ByteArray!, passwdlen: Long, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_str_alg(out: ByteArray!, passwd: ByteArray!, passwdlen: Long, opslimit: Long, memlimit: Long, alg: Int): Int

abstract fun crypto_pwhash_str_needs_rehash(str: Pointer!, opslimit: Long, memlimit: Long): Int

abstract fun crypto_pwhash_str_verify(str: Pointer!, passwd: ByteArray!, passwdlen: Long): Int

abstract fun crypto_pwhash_strbytes(): Long

abstract fun crypto_pwhash_strprefix(): String!

abstract fun crypto_scalarmult(q: Pointer!, n: Pointer!, p: Pointer!): Int

abstract fun crypto_scalarmult_base(q: Pointer!, n: Pointer!): Int

abstract fun crypto_scalarmult_bytes(): Long

abstract fun crypto_scalarmult_curve25519(q: ByteArray!, n: ByteArray!, p: ByteArray!): Int

abstract fun crypto_scalarmult_curve25519_base(q: ByteArray!, n: ByteArray!): Int

abstract fun crypto_scalarmult_curve25519_bytes(): Long

abstract fun crypto_scalarmult_curve25519_scalarbytes(): Long

abstract fun crypto_scalarmult_ed25519(q: ByteArray!, n: ByteArray!, p: ByteArray!): Int

abstract fun crypto_scalarmult_ed25519_base(q: ByteArray!, n: ByteArray!): Int

abstract fun crypto_scalarmult_ed25519_base_noclamp(q: ByteArray!, n: ByteArray!): Int

abstract fun crypto_scalarmult_ed25519_bytes(): Long

abstract fun crypto_scalarmult_ed25519_noclamp(q: ByteArray!, n: ByteArray!, p: ByteArray!): Int

abstract fun crypto_scalarmult_ed25519_scalarbytes(): Long

abstract fun crypto_scalarmult_primitive(): String!

abstract fun crypto_scalarmult_ristretto255(q: ByteArray!, n: ByteArray!, p: ByteArray!): Int

abstract fun crypto_scalarmult_ristretto255_base(q: ByteArray!, n: ByteArray!): Int

abstract fun crypto_scalarmult_ristretto255_bytes(): Long

abstract fun crypto_scalarmult_ristretto255_scalarbytes(): Long

abstract fun crypto_scalarmult_scalarbytes(): Long

abstract fun crypto_secretbox(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_secretbox_boxzerobytes(): Long

abstract fun crypto_secretbox_detached(c: ByteArray!, mac: ByteArray!, m: ByteArray!, mlen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_secretbox_easy(c: Pointer!, m: Pointer!, mlen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_secretbox_easy(c: ByteArray!, m: ByteArray!, mlen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_secretbox_keybytes(): Long

abstract fun crypto_secretbox_keygen(k: Pointer!): Unit

abstract fun crypto_secretbox_macbytes(): Long

abstract fun crypto_secretbox_messagebytes_max(): Long

abstract fun crypto_secretbox_noncebytes(): Long

abstract fun crypto_secretbox_open(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_secretbox_open_detached(m: ByteArray!, c: ByteArray!, mac: ByteArray!, clen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_secretbox_open_easy(m: ByteArray!, c: ByteArray!, clen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_secretbox_open_easy(m: Pointer!, c: Pointer!, clen: Long, n: Pointer!, k: Pointer!): Int

abstract fun crypto_secretbox_primitive(): String!

abstract fun crypto_secretbox_xchacha20poly1305_detached(c: ByteArray!, mac: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_secretbox_xchacha20poly1305_easy(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_secretbox_xchacha20poly1305_keybytes(): Long

abstract fun crypto_secretbox_xchacha20poly1305_macbytes(): Long

abstract fun crypto_secretbox_xchacha20poly1305_messagebytes_max(): Long

abstract fun crypto_secretbox_xchacha20poly1305_noncebytes(): Long

abstract fun crypto_secretbox_xchacha20poly1305_open_detached(m: ByteArray!, c: ByteArray!, mac: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_secretbox_xchacha20poly1305_open_easy(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_secretbox_xsalsa20poly1305(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_secretbox_xsalsa20poly1305_boxzerobytes(): Long

abstract fun crypto_secretbox_xsalsa20poly1305_keybytes(): Long

abstract fun crypto_secretbox_xsalsa20poly1305_keygen(k: ByteArray!): Unit

abstract fun crypto_secretbox_xsalsa20poly1305_macbytes(): Long

abstract fun crypto_secretbox_xsalsa20poly1305_messagebytes_max(): Long

abstract fun crypto_secretbox_xsalsa20poly1305_noncebytes(): Long

abstract fun crypto_secretbox_xsalsa20poly1305_open(m: ByteArray!, c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_secretbox_xsalsa20poly1305_zerobytes(): Long

abstract fun crypto_secretbox_zerobytes(): Long

abstract fun crypto_secretstream_xchacha20poly1305_abytes(): Long

abstract fun crypto_secretstream_xchacha20poly1305_headerbytes(): Long

abstract fun crypto_secretstream_xchacha20poly1305_init_pull(state: Pointer!, : ByteArray!, k: Pointer!): Int

abstract fun crypto_secretstream_xchacha20poly1305_init_push(state: Pointer!, : ByteArray!, k: Pointer!): Int

abstract fun crypto_secretstream_xchacha20poly1305_keybytes(): Long

abstract fun crypto_secretstream_xchacha20poly1305_keygen(k: Pointer!): Unit

abstract fun crypto_secretstream_xchacha20poly1305_messagebytes_max(): Long

abstract fun crypto_secretstream_xchacha20poly1305_push(state: Pointer!, c: ByteArray!, clen_p: LongLongByReference!, m: ByteArray!, mlen: Long, ad: ByteArray!, adlen: Long, tag: Byte): Int

abstract fun crypto_secretstream_xchacha20poly1305_rekey(state: Pointer!): Unit

abstract fun crypto_secretstream_xchacha20poly1305_statebytes(): Long

abstract fun crypto_secretstream_xchacha20poly1305_tag_final(): Char

abstract fun crypto_secretstream_xchacha20poly1305_tag_message(): Char

abstract fun crypto_secretstream_xchacha20poly1305_tag_push(): Char

abstract fun crypto_secretstream_xchacha20poly1305_tag_rekey(): Char

abstract fun crypto_shorthash(out: ByteArray!, in: ByteArray!, inlen: Long, k: ByteArray!): Int

abstract fun crypto_shorthash_bytes(): Long

abstract fun crypto_shorthash_keybytes(): Long

abstract fun crypto_shorthash_keygen(k: ByteArray!): Unit

abstract fun crypto_shorthash_primitive(): String!

abstract fun crypto_shorthash_siphash24(out: ByteArray!, in: ByteArray!, inlen: Long, k: ByteArray!): Int

abstract fun crypto_shorthash_siphash24_bytes(): Long

abstract fun crypto_shorthash_siphash24_keybytes(): Long

abstract fun crypto_shorthash_siphashx24(out: ByteArray!, in: ByteArray!, inlen: Long, k: ByteArray!): Int

abstract fun crypto_shorthash_siphashx24_bytes(): Long

abstract fun crypto_shorthash_siphashx24_keybytes(): Long

abstract fun crypto_sign(sm: ByteArray!, @Nullable smlen_p: LongLongByReference?, m: ByteArray!, mlen: Long, sk: Pointer!): Int

abstract fun crypto_sign_bytes(): Long

abstract fun crypto_sign_detached(sig: ByteArray!, @Nullable siglen_p: LongLongByReference?, m: ByteArray!, mlen: Long, sk: Pointer!): Int

abstract fun crypto_sign_detached(sig: Pointer!, @Nullable siglen_p: LongLongByReference?, m: Pointer!, mlen: Long, sk: Pointer!): Int

abstract fun crypto_sign_ed25519(sm: ByteArray!, smlen_p: LongLongByReference!, m: ByteArray!, mlen: Long, sk: ByteArray!): Int

abstract fun crypto_sign_ed25519_bytes(): Long

abstract fun crypto_sign_ed25519_detached(sig: ByteArray!, siglen_p: LongLongByReference!, m: ByteArray!, mlen: Long, sk: ByteArray!): Int

abstract fun crypto_sign_ed25519_keypair(pk: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_sign_ed25519_messagebytes_max(): Long

abstract fun crypto_sign_ed25519_open(m: ByteArray!, mlen_p: LongLongByReference!, sm: ByteArray!, smlen: Long, pk: ByteArray!): Int

abstract fun crypto_sign_ed25519_pk_to_curve25519(curve25519_pk: Pointer!, ed25519_pk: Pointer!): Int

abstract fun crypto_sign_ed25519_publickeybytes(): Long

abstract fun crypto_sign_ed25519_secretkeybytes(): Long

abstract fun crypto_sign_ed25519_seed_keypair(pk: ByteArray!, sk: ByteArray!, seed: ByteArray!): Int

abstract fun crypto_sign_ed25519_seedbytes(): Long

abstract fun crypto_sign_ed25519_sk_to_curve25519(curve25519_sk: Pointer!, ed25519_sk: Pointer!): Int

abstract fun crypto_sign_ed25519_sk_to_pk(pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_sign_ed25519_sk_to_seed(seed: ByteArray!, sk: ByteArray!): Int

abstract fun crypto_sign_ed25519_verify_detached(sig: ByteArray!, m: ByteArray!, mlen: Long, pk: ByteArray!): Int

abstract fun crypto_sign_ed25519ph_final_create(state: Pointer!, sig: ByteArray!, siglen_p: LongLongByReference!, sk: ByteArray!): Int

abstract fun crypto_sign_ed25519ph_final_verify(state: Pointer!, sig: ByteArray!, pk: ByteArray!): Int

abstract fun crypto_sign_ed25519ph_init(state: Pointer!): Int

abstract fun crypto_sign_ed25519ph_statebytes(): Long

abstract fun crypto_sign_ed25519ph_update(state: Pointer!, m: ByteArray!, mlen: Long): Int

abstract fun crypto_sign_final_create(state: Pointer!, sig: ByteArray!, siglen_p: LongLongByReference!, sk: ByteArray!): Int

abstract fun crypto_sign_final_verify(state: Pointer!, sig: ByteArray!, pk: ByteArray!): Int

abstract fun crypto_sign_init(state: Pointer!): Int

abstract fun crypto_sign_keypair(pk: Pointer!, sk: Pointer!): Int

abstract fun crypto_sign_messagebytes_max(): Long

abstract fun crypto_sign_open(m: ByteArray!, mlen_p: LongLongByReference!, sm: ByteArray!, smlen: Long, pk: Pointer!): Int

abstract fun crypto_sign_primitive(): String!

abstract fun crypto_sign_publickeybytes(): Long

abstract fun crypto_sign_secretkeybytes(): Long

abstract fun crypto_sign_seed_keypair(pk: Pointer!, sk: Pointer!, seed: Pointer!): Int

abstract fun crypto_sign_seedbytes(): Long

abstract fun crypto_sign_statebytes(): Long

abstract fun crypto_sign_update(state: Pointer!, m: ByteArray!, mlen: Long): Int

abstract fun crypto_sign_verify_detached(sig: Pointer!, m: Pointer!, mlen: Long, pk: Pointer!): Int

abstract fun crypto_sign_verify_detached(sig: ByteArray!, m: ByteArray!, mlen: Long, pk: Pointer!): Int

abstract fun crypto_stream(c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_chacha20(c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_chacha20_ietf(c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_chacha20_ietf_keybytes(): Long

abstract fun crypto_stream_chacha20_ietf_keygen(k: ByteArray!): Unit

abstract fun crypto_stream_chacha20_ietf_messagebytes_max(): Long

abstract fun crypto_stream_chacha20_ietf_noncebytes(): Long

abstract fun crypto_stream_chacha20_ietf_xor(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_chacha20_ietf_xor_ic(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, ic: Int, k: ByteArray!): Int

abstract fun crypto_stream_chacha20_keybytes(): Long

abstract fun crypto_stream_chacha20_keygen(k: ByteArray!): Unit

abstract fun crypto_stream_chacha20_messagebytes_max(): Long

abstract fun crypto_stream_chacha20_noncebytes(): Long

abstract fun crypto_stream_chacha20_xor(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_chacha20_xor_ic(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, ic: Long, k: ByteArray!): Int

abstract fun crypto_stream_keybytes(): Long

abstract fun crypto_stream_keygen(k: ByteArray!): Unit

abstract fun crypto_stream_messagebytes_max(): Long

abstract fun crypto_stream_noncebytes(): Long

abstract fun crypto_stream_primitive(): String!

abstract fun crypto_stream_salsa20(c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_salsa2012(c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_salsa2012_keybytes(): Long

abstract fun crypto_stream_salsa2012_keygen(k: ByteArray!): Unit

abstract fun crypto_stream_salsa2012_messagebytes_max(): Long

abstract fun crypto_stream_salsa2012_noncebytes(): Long

abstract fun crypto_stream_salsa2012_xor(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_salsa208(c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_salsa208_keybytes(): Long

abstract fun crypto_stream_salsa208_keygen(k: ByteArray!): Unit

abstract fun crypto_stream_salsa208_messagebytes_max(): Long

abstract fun crypto_stream_salsa208_noncebytes(): Long

abstract fun crypto_stream_salsa208_xor(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_salsa20_keybytes(): Long

abstract fun crypto_stream_salsa20_keygen(k: ByteArray!): Unit

abstract fun crypto_stream_salsa20_messagebytes_max(): Long

abstract fun crypto_stream_salsa20_noncebytes(): Long

abstract fun crypto_stream_salsa20_xor(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_salsa20_xor_ic(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, ic: Long, k: ByteArray!): Int

abstract fun crypto_stream_xchacha20(c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_xchacha20_keybytes(): Long

abstract fun crypto_stream_xchacha20_keygen(k: ByteArray!): Unit

abstract fun crypto_stream_xchacha20_messagebytes_max(): Long

abstract fun crypto_stream_xchacha20_noncebytes(): Long

abstract fun crypto_stream_xchacha20_xor(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_xchacha20_xor_ic(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, ic: Long, k: ByteArray!): Int

abstract fun crypto_stream_xor(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_xsalsa20(c: ByteArray!, clen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_xsalsa20_keybytes(): Long

abstract fun crypto_stream_xsalsa20_keygen(k: ByteArray!): Unit

abstract fun crypto_stream_xsalsa20_messagebytes_max(): Long

abstract fun crypto_stream_xsalsa20_noncebytes(): Long

abstract fun crypto_stream_xsalsa20_xor(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, k: ByteArray!): Int

abstract fun crypto_stream_xsalsa20_xor_ic(c: ByteArray!, m: ByteArray!, mlen: Long, n: ByteArray!, ic: Long, k: ByteArray!): Int

abstract fun crypto_verify_16(x: ByteArray!, y: ByteArray!): Int

abstract fun crypto_verify_16_bytes(): Long

abstract fun crypto_verify_32(x: ByteArray!, y: ByteArray!): Int

abstract fun crypto_verify_32_bytes(): Long

abstract fun crypto_verify_64(x: ByteArray!, y: ByteArray!): Int

abstract fun crypto_verify_64_bytes(): Long

abstract fun implementation_name(): String!

abstract fun random(): Int

abstract fun randombytes(buf: ByteArray!, buf_len: Long): Unit

abstract fun randombytes_buf(buf: Pointer!, size: Long): Unit

abstract fun randombytes_buf_deterministic(buf: ByteArray!, size: Long, seed: ByteArray!): Unit

abstract fun randombytes_close(): Int

abstract fun randombytes_implementation_name(): String!

abstract fun randombytes_random(): Int

abstract fun randombytes_seedbytes(): Long

abstract fun randombytes_set_implementation(impl: Pointer!): Int

abstract fun randombytes_stir(): Unit

abstract fun randombytes_uniform(upper_bound: Int): Int

abstract fun sodium_add(a: Pointer!, b: Pointer!, len: Long): Unit

abstract fun sodium_allocarray(count: Long, size: Long): Pointer!

abstract fun sodium_base642bin(bin: ByteArray!, bin_maxlen: Long, b64: ByteArray!, b64_len: Long, ignore: ByteArray!, bin_len: LongLongByReference!, b64_end: Pointer!, variant: Int): Int

abstract fun sodium_base64_encoded_len(bin_len: Long, variant: Int): Long

abstract fun sodium_compare(b1_: Pointer!, b2_: Pointer!, len: Long): Int

abstract fun sodium_free(ptr: Pointer!): Unit

abstract fun sodium_hex2bin(bin: ByteArray!, bin_maxlen: Long, hex: ByteArray!, hex_len: Long, ignore: ByteArray!, bin_len: LongLongByReference!, hex_end: Pointer!): Int

abstract fun sodium_increment(n: Pointer!, nlen: Long): Unit

abstract fun sodium_init(): Int

abstract fun sodium_is_zero(n: Pointer!, nlen: Long): Int

abstract fun sodium_library_minimal(): Int

abstract fun sodium_library_version_major(): Int

abstract fun sodium_library_version_minor(): Int

abstract fun sodium_malloc(size: Long): Pointer!

abstract fun sodium_memcmp(b1_: Pointer!, b2_: Pointer!, len: Long): Int

abstract fun sodium_memzero(pnt: Pointer!, len: Long): Unit

abstract fun sodium_misuse(): Unit

abstract fun sodium_mlock(addr: Pointer!, len: Long): Int

abstract fun sodium_mprotect_noaccess(ptr: Pointer!): Int

abstract fun sodium_mprotect_readonly(ptr: Pointer!): Int

abstract fun sodium_mprotect_readwrite(ptr: Pointer!): Int

abstract fun sodium_munlock(addr: Pointer!, len: Long): Int

abstract fun sodium_pad(padded_buflen_p: LongLongByReference!, buf: ByteArray!, unpadded_buflen: Long, blocksize: Long, max_buflen: Long): Int

abstract fun sodium_runtime_has_aesni(): Int

abstract fun sodium_runtime_has_avx(): Int

abstract fun sodium_runtime_has_avx2(): Int

abstract fun sodium_runtime_has_avx512f(): Int

abstract fun sodium_runtime_has_neon(): Int

abstract fun sodium_runtime_has_pclmul(): Int

abstract fun sodium_runtime_has_rdrand(): Int

abstract fun sodium_runtime_has_sse2(): Int

abstract fun sodium_runtime_has_sse3(): Int

abstract fun sodium_runtime_has_sse41(): Int

abstract fun sodium_runtime_has_ssse3(): Int

abstract fun sodium_set_misuse_handler(handler: Pointer!): Int

abstract fun sodium_stackzero(len: Long): Unit

abstract fun sodium_sub(a: ByteArray!, b: ByteArray!, len: Long): Unit

abstract fun sodium_unpad(unpadded_buflen_p: LongLongByReference!, buf: ByteArray!, padded_buflen: Long, blocksize: Long): Int

abstract fun sodium_version_string(): String!

abstract fun stir(): Unit

abstract fun uniform(upper_bound: Int): Int

class PasswordHash

Module Contents

PasswordHash()

class Algorithm

Module Contents

static fun argon2i13(): Algorithm!

static fun argon2id13(): Algorithm!

fun isSupported(): Boolean

fun name(): String!

static fun recommended(): Algorithm!

static fun checkHash(hash: String!, password: String!): VerificationResult!

static fun checkHash(hash: String!, password: String!, opsLimit: Long, memLimit: Long): VerificationResult!

static fun checkHashForInteractive(hash: String!, password: String!): VerificationResult!

static fun checkHashForSensitive(hash: String!, password: String!): VerificationResult!

static fun hash(password: String!, length: Int, salt: Salt!):

length

Int

salt

Salt

)

static fun hash(password: ByteArray!, length: Int, salt: Salt!): ByteArray!

static fun hash(password: String!, length: Int, salt: Salt!, algorithm: Algorithm!):

length

Int

salt

Salt

algorithm

Algorithm

)

static fun hash(password: ByteArray!, length: Int, salt: Salt!, algorithm: Algorithm!): ByteArray!

static fun hash(password: String!, length: Int, salt: Salt!, opsLimit: Long, memLimit: Long, algorithm: Algorithm!):

length

Int

salt

Salt

opsLimit

Long

memLimit

Long

algorithm

Algorithm

)

static fun hash(password: ByteArray!, length: Int, salt: Salt!, opsLimit: Long, memLimit: Long, algorithm: Algorithm!): ByteArray!

static fun hash(password: String!): String!

static fun hash(password: String!, opsLimit: Long, memLimit: Long): String!

static fun hashInteractive(password: String!, length: Int, salt: Salt!):

length

Int

salt

Salt

)

static fun hashInteractive(password: ByteArray!, length: Int, salt: Salt!): ByteArray!

static fun hashInteractive(password: String!, length: Int, salt: Salt!, algorithm: Algorithm!):

length

Int

salt

Salt

algorithm

Algorithm

)

static fun hashInteractive(password: ByteArray!, length: Int, salt: Salt!, algorithm: Algorithm!): ByteArray!

static fun hashInteractive(password: String!): String!

static fun hashSensitive(password: String!, length: Int, salt: Salt!):

length

Int

salt

Salt

)

static fun hashSensitive(password: ByteArray!, length: Int, salt: Salt!): ByteArray!

static fun hashSensitive(password: String!, length: Int, salt: Salt!, algorithm: Algorithm!):

length

Int

salt

Salt

algorithm

Algorithm

)

static fun hashSensitive(password: ByteArray!, length: Int, salt: Salt!, algorithm: Algorithm!): ByteArray!

static fun hashSensitive(password: String!): String!

static fun interactiveMemLimit(): Long

static fun interactiveOpsLimit(): Long

static fun maxHashLength(): Int

static fun maxMemLimit(): Long

static fun maxOpsLimit(): Long

static fun minHashLength(): Int

static fun minMemLimit(): Long

static fun minOpsLimit(): Long

static fun moderateMemLimit(): Long

static fun moderateOpsLimit(): Long

static fun needsRehash(hash: String!): Boolean

static fun needsRehash(hash: String!, opsLimit: Long, memLimit: Long): Boolean

static fun needsRehashForInteractive(hash: String!): Boolean

static fun needsRehashForSensitive(hash: String!): Boolean

class Salt

Module Contents

static fun fromBytes(bytes: ByteArray!): Salt!

)

Salt

static fun random(): Salt!

static fun sensitiveMemLimit(): Long

static fun sensitiveOpsLimit(): Long

class VerificationResult

Module Contents

FAILED

NEEDS_REHASH

fun needsRehash(): Boolean

PASSED

fun passed(): Boolean

static fun verify(hash: String!, password: String!): Boolean

class SecretBox

Module Contents

key

Key

nonce

Nonce

)

key

Key

nonce

Nonce

)

@Nullable static fun decrypt(cipherText: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

password

String

)

@Nullable static fun decrypt(cipherText: ByteArray!, password: String!): ByteArray?

password

String

algorithm

Algorithm

)

@Nullable static fun decrypt(cipherText: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray?

password

String

opsLimit

Long

memLimit

Long

algorithm

Algorithm

)

@Nullable static fun decrypt(cipherText: ByteArray!, password: String!, opsLimit: Long, memLimit: Long, algorithm: Algorithm!): ByteArray?

mac

key

Key

nonce

Nonce

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

mac

password

String

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, password: String!): ByteArray?

mac

password

String

algorithm

Algorithm

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray?

mac

password

String

opsLimit

Long

memLimit

Long

algorithm

Algorithm

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, password: String!, opsLimit: Long, memLimit: Long, algorithm: Algorithm!): ByteArray?

@Nullable static fun decryptInteractive(cipherText:

password

String

)

@Nullable static fun decryptInteractive(cipherText: ByteArray!, password: String!): ByteArray?

@Nullable static fun decryptInteractive(cipherText:

password

String

algorithm

Algorithm

)

@Nullable static fun decryptInteractive(cipherText: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray?

@Nullable static fun decryptInteractiveDetached(cipherText:

mac

password

String

)

@Nullable static fun decryptInteractiveDetached(cipherText: ByteArray!, mac: ByteArray!, password: String!): ByteArray?

@Nullable static fun decryptInteractiveDetached(cipherText:

mac

password

String

algorithm

Algorithm

)

@Nullable static fun decryptInteractiveDetached(cipherText: ByteArray!, mac: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray?

password

String

)

@Nullable static fun decryptSensitive(cipherText: ByteArray!, password: String!): ByteArray?

password

String

algorithm

Algorithm

)

@Nullable static fun decryptSensitive(cipherText: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray?

@Nullable static fun decryptSensitiveDetached(cipherText:

mac

password

String

)

@Nullable static fun decryptSensitiveDetached(cipherText: ByteArray!, mac: ByteArray!, password: String!): ByteArray?

@Nullable static fun decryptSensitiveDetached(cipherText:

mac

password

String

algorithm

Algorithm

)

@Nullable static fun decryptSensitiveDetached(cipherText: ByteArray!, mac: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray?

key

Key

nonce

Nonce

)

key

Key

nonce

Nonce

)

static fun encrypt(message: ByteArray!, key: Key!, nonce: Nonce!): ByteArray!

password

String

)

static fun encrypt(message: ByteArray!, password: String!): ByteArray!

password

String

algorithm

Algorithm

)

static fun encrypt(message: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray!

password

String

opsLimit

Long

memLimit

Long

algorithm

Algorithm

)

static fun encrypt(message: ByteArray!, password: String!, opsLimit: Long, memLimit: Long, algorithm: Algorithm!): ByteArray!

key

Key

nonce

Nonce

)

static fun encryptDetached(message: ByteArray!, key: Key!, nonce: Nonce!):

password

String

)

static fun encryptDetached(message: ByteArray!, password: String!):

password

String

algorithm

Algorithm

)

static fun encryptDetached(message: ByteArray!, password: String!, algorithm: Algorithm!):

password

String

opsLimit

Long

memLimit

Long

algorithm

Algorithm

)

static fun encryptDetached(message: ByteArray!, password: String!, opsLimit: Long, memLimit: Long, algorithm: Algorithm!):

password

String

)

static fun encryptInteractive(message: ByteArray!, password: String!): ByteArray!

password

String

algorithm

Algorithm

)

static fun encryptInteractive(message: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray!

password

String

)

static fun encryptInteractiveDetached(message: ByteArray!, password: String!):

password

String

algorithm

Algorithm

)

static fun encryptInteractiveDetached(message: ByteArray!, password: String!, algorithm: Algorithm!):

password

String

)

static fun encryptSensitive(message: ByteArray!, password: String!): ByteArray!

password

String

algorithm

Algorithm

)

static fun encryptSensitive(message: ByteArray!, password: String!, algorithm: Algorithm!): ByteArray!

password

String

)

static fun encryptSensitiveDetached(message: ByteArray!, password: String!):

password

String

algorithm

Algorithm

)

static fun encryptSensitiveDetached(message: ByteArray!, password: String!, algorithm: Algorithm!):

Module Contents

)

Key

class Nonce : Destroyable

Module Contents

)

Nonce

interface SecretDecryptionStream : Destroyable

Module Contents

open fun pull(cipherText:

)

abstract fun pull(cipherText: ByteArray!): ByteArray!

interface SecretEncryptionStream : Destroyable

Module Contents

open fun header():

abstract fun headerArray(): ByteArray!

)

open fun push(clearText: ByteArray!): ByteArray!

isFinal

Boolean

)

abstract fun push(clearText: ByteArray!, isFinal: Boolean): ByteArray!

open fun pushLast(clearText:

)

open fun pushLast(clearText: ByteArray!): ByteArray!

open class SHA256Hash

Module Contents

SHA256Hash()

Module Contents

open static fun hash(input: Input!): Hash!

Module Contents

)

Input

static fun fromSecret(secret: Secret!): Input!

)

Input

Module Contents

KeyPair(publicKey: PublicKey!, secretKey: SecretKey!)

Module Contents

static fun forSecretKey(secretKey: SecretKey!): KeyPair!

Module Contents

static fun fromBytes(bytes: ByteArray!): PublicKey!

)

PublicKey

signature

)

Boolean

signature

)

Boolean

Module Contents

static fun fromBytes(bytes: ByteArray!): SecretKey!

)

SecretKey

static fun fromSeed(seed: Seed!): SecretKey!

Module Contents

)

Seed

static fun sign(message:

secretKey

SecretKey

)

static fun sign(message: ByteArray!, secretKey: SecretKey!): ByteArray!

secretKey

SecretKey

)

secretKey

SecretKey

)

static fun signDetached(message: ByteArray!, secretKey: SecretKey!): ByteArray!

static fun verify(signed:

publicKey

PublicKey

)

static fun verify(signed: ByteArray!, publicKey: PublicKey!): ByteArray!

signature

publicKey

PublicKey

)

Boolean

signature

static fun verifyDetached(message: ByteArray!, signature: ByteArray!, publicKey: PublicKey!): Boolean

publicKey

PublicKey

)

Boolean

class Sodium

Module Contents

static fun loadLibrary(path: Path!): Unit

static fun minSupportedVersion():

static fun searchLibrary(vararg paths: Path!): Unit

static fun searchLibrary(libraryName: String!, vararg paths: Path!): Unit

static fun supportsVersion(requiredVersion:

)

Boolean

static fun version():

class SodiumException : RuntimeException

Module Contents

SodiumException(message: String!)

class SodiumVersion : Comparable<

Module Contents

fun compareTo(other:

)

Int

fun major(): Int

fun minor(): Int

class XChaCha20Poly1305

Module Contents

key

Key

nonce

Nonce

)

@Nullable static fun decrypt(cipherText: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

data

key

Key

nonce

Nonce

)

@Nullable static fun decrypt(cipherText: ByteArray!, data: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

static fun decryptDetached(cipherText:

mac

key

Key

nonce

Nonce

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

mac

data

key

Key

nonce

Nonce

)

@Nullable static fun decryptDetached(cipherText: ByteArray!, mac: ByteArray!, data: ByteArray!, key: Key!, nonce: Nonce!): ByteArray?

key

Key

nonce

Nonce

)

static fun encrypt(message: ByteArray!, key: Key!, nonce: Nonce!): ByteArray!

data

key

Key

nonce

Nonce

)

static fun encrypt(message: ByteArray!, data: ByteArray!, key: Key!, nonce: Nonce!): ByteArray!

key

Key

nonce

Nonce

)

static fun encryptDetached(message: ByteArray!, key: Key!, nonce: Nonce!):

data

key

Key

nonce

Nonce

)

static fun encryptDetached(message: ByteArray!, data: ByteArray!, key: Key!, nonce: Nonce!):

static fun isSecretStreamAvailable(): Boolean

Module Contents

)

Key

Module Contents

)

Nonce

static fun openDecryptionStream(key: Key!, : ByteArray!):

SecretDecryptionStream

static fun openEncryptionStream(key: Key!):

SecretEncryptionStream

package org.apache.tuweni.devp2p

Module Contents

interface DiscoveryService

Module Contents

abstract suspend fun awaitBootstrap(): Unit

abstract fun awaitBootstrapAsync():

abstract val expiredPackets: Long

abstract val filteredPackets: Long

abstract val invalidPackets: Long

abstract val isShutdown: Boolean

abstract val localPort: Int

abstract suspend fun lookup(target: PublicKey): List<

abstract fun lookupAsync(target: PublicKey):

List

@JvmOverloads fun open(vertx: Vertx, keyPair: KeyPair, port: Int = 0, host: String? = null, seq: Long = Instant.now().toEpochMilli(), enrData: Map<String,

bootstrapURIs

List

URI

peerRepository

advertiseAddress

String

advertiseUdpPort

Int

advertiseTcpPort

Int

routingTable

packetFilter

(

PublicKey

SocketAddress

)

Boolean

)

timeSupplier

(

)

Long

)

@JvmOverloads fun open(vertx: Vertx, keyPair: KeyPair, bindAddress: SocketAddress, seq: Long = Instant.now().toEpochMilli(), enrData: Map<String,

bootstrapURIs

List

URI

peerRepository

advertiseAddress

String

advertiseUdpPort

Int

advertiseTcpPort

Int

routingTable

packetFilter

(

PublicKey

SocketAddress

)

Boolean

)

timeSupplier

(

)

Long

)

abstract val selfPackets: Long

abstract suspend fun shutdown(): Unit

abstract fun shutdownAsync():

abstract val unexpectedENRResponses: Long

abstract val unexpectedNeighbors: Long

abstract val unexpectedPongs: Long

abstract val unvalidatedPeerPackets: Long

data class Endpoint

Module Contents

Endpoint(address: SocketAddress, tcpPort: Int? = null)

Endpoint(address: String, udpPort: Int = DEFAULT_PORT, tcpPort: Int? = null)

val address: String

const val DEFAULT_PORT: Int

)

val tcpSocketAddress: InetSocketAddress?

val udpPort: Int

val udpSocketAddress: SocketAddress

data class EnodeUriComponents

Module Contents

EnodeUriComponents(nodeId: PublicKey, endpoint:

)

val endpoint:

val nodeId: PublicKey

Module Contents

fun get(nodeId: PublicKey, endpoint:

)

suspend fun get(host: String, port: Int, nodeId: PublicKey):

EthereumNodeRecord(signature:

class EthereumNodeRecord

Module Contents

seq

Long

data

Map

String

listData

Map

String

List

rlp

@JvmOverloads @JvmStatic fun create(signatureKeyPair: KeyPair, seq: Long = Instant.now().toEpochMilli(), data: Map<String,

)

listData

Map

String

List

InetAddress

tcp

Int

udp

Int

)

val data: Map<String,

fun encode(signatureKeyPair: KeyPair? = null, seq: Long = Instant.now().toEpochMilli(), ip: InetAddress? = null, tcp: Int? = null, udp: Int? = null, data: Map<String,

listData

Map

String

List

writer

)

Unit

@JvmStatic fun fromRLP(rlp:

)

)

val listData: Map<String, List<

rlp

)

fun ip(): InetAddress

fun nodeId(publicKey: PublicKey):

fun publicKey(): PublicKey

fun publicKeyBytes():

@JvmOverloads @JvmStatic fun toRLP(signatureKeyPair: KeyPair, seq: Long = Instant.now().toEpochMilli(), data: Map<String,

listData

Map

String

List

InetAddress

tcp

Int

udp

Int

)

fun parseEnodeUri(uri: URI):

fun udp(): Int?

fun validate(): Unit

EnodeUriComponents

Module Contents

abstract val endpoint:

abstract val enr:

abstract fun getEndpoint(ifVerifiedOnOrAfter: Long):

abstract val lastSeen: Long?

abstract val lastVerified: Long?

abstract fun seenAt(time: Long): Unit

abstract fun updateEndpoint(endpoint:

time

Long

ifVerifiedBefore

Long

)

abstract fun updateENR(record:

abstract fun verifyEndpoint(endpoint:

time

Long

)

Unit

open fun uri(): String

time

Long

)

Boolean

abstract suspend fun get(host: String, port: Int, nodeId: PublicKey):

Module Contents

abstract suspend fun get(uri: URI):

open suspend fun get(uri: String):

abstract fun getAsync(uri: URI):

abstract fun getAsync(uri: String):

interface PeerRoutingTable : Set<

Module Contents

abstract fun add(node:

)

abstract fun evict(node:

abstract fun nearest(targetId: PublicKey, limit: Int): List<

)

Boolean

Module Contents

List

val bindAddress: SocketAddress

)

Unit

maxWaitForNewPeers

Long

waitBetweenScrapes

Long

)

fun discover(maxWaitForNewPeers: Long): Deferred<Unit>

val initialURIs: List<URI>

List

)

Unit

Module Contents

package org.apache.tuweni.devp2p.eth

Module Contents

interface BlockchainInformation

Module Contents

abstract fun bestHash():

abstract fun bestNumber():

abstract fun forks(): List<Long>

abstract fun genesisHash():

open fun getForkHashes(): List<

open fun getLatestFork(): Long?

open fun getLatestForkHash():

abstract fun networkID():

abstract fun totalDifficulty():

Module Contents

pendingTransactionsPool

fun nodeDataWasRequested(connection:

)

elements

List

)

fun requestBlock(blockHash:

)

fun requestBlockBodies(blockHashes: List<

)

)

fun requestBlockHeaders(blockHash:

maxHeaders

Long

skip

Long

reverse

Boolean

)

fun requestBlockHeaders(blockNumber: Long, maxHeaders: Long, skip: Long, reverse: Boolean):

fun requestBlockHeaders(blockHashes: List<

)

fun requestTransactionReceipts(blockHashes: List<

)

suspend fun submitPooledTransaction(vararg tx:

fun transactionReceiptsRequested(connection:

)

Unit

transactionReceipts

List

)

)

bodies

List

)

EthController(repository:

class EthController

Module Contents

pendingTransactionsPool

requestsManager

connectionsListener

(

suspend fun addNewBlock(newBlock:

)

Unit

)

suspend fun addNewBlockBodies(connection:

)

Unit

bodies

List

suspend fun addNewBlockHashes(hashes: List<Pair<

)

Unit

suspend fun addNewBlockHeaders(connection:

Long

)

Unit

headers

List

suspend fun addNewNodeData(connection:

)

Unit

elements

List

suspend fun addNewPooledTransactions(transactions: List<

)

Unit

suspend fun addNewTransactionReceipts(connection:

)

Unit

transactionReceipts

List

suspend fun addNewTransactions(transactions: List<

)

Unit

val connectionsListener: (

)

Unit

suspend fun findBlockBodies(hashes: List<

)

Unit

)

List

suspend fun findHeaders(block:

maxHeaders

Long

skip

Long

reverse

Boolean

)

List

suspend fun findNodeData(hashes: List<

)

List

suspend fun findPooledTransactions(hashes: List<

)

List

suspend fun findTransactionReceipts(hashes: List<

)

List

val pendingTransactionsPool:

fun receiveStatus(connection:

status

)

Unit

)

Unit

val requestsManager:

interface EthRequestsManager

Module Contents

abstract fun nodeDataWasRequested(connection:

elements

List

)

abstract fun requestBlock(blockHash:

)

abstract fun requestBlockBodies(blockHashes: List<

)

abstract fun requestBlockHeader(blockHash:

)

abstract fun requestBlockHeaders(blockHashes: List<

)

abstract fun requestBlockHeaders(blockHash:

maxHeaders

Long

skip

Long

reverse

Boolean

)

abstract fun requestBlockHeaders(blockNumber: Long, maxHeaders: Long, skip: Long, reverse: Boolean):

abstract fun requestTransactionReceipts(blockHashes: List<

)

abstract suspend fun submitPooledTransaction(vararg tx:

abstract fun transactionReceiptsRequested(connection:

)

Unit

transactionReceipts

List

)

)

bodies

List

)

class EthSubprotocol :

EthSubprotocol(coroutineContext: CoroutineContext = Dispatchers.Default, blockchainInfo:

Module Contents

repository

pendingTransactionsPool

listener

(

)

Unit

)

)

client

)

val ETH63:

val ETH64:

val ETH65:

fun getCapabilities(): MutableList<

fun id():

)

Boolean

Request(connectionId: String, handle:

data class Request

Module Contents

data

Any

)

val connectionId: String

val data: Any

val handle:

data class SimpleBlockchainInformation :

SimpleBlockchainInformation(networkID:

Module Contents

totalDifficulty

bestHash

bestNumber

genesisHash

forks

List

Long

)

fun forks(): List<Long>

val forks: List<Long>

fun totalDifficulty():

Module Contents

Status(protocolVersion: Int, networkID:

totalDifficulty

bestHash

genesisHash

forkHash

forkBlock

Long

)

val protocolVersion: Int

val totalDifficulty:

package org.apache.tuweni.devp2p.v5

Module Contents

object DiscoveryService

Module Contents

ENRStorage

coroutineContext

CoroutineContext

)

DiscoveryV5Service

interface DiscoveryV5Service : CoroutineScope

Module Contents

open suspend fun addPeer(rlpENR:

)

abstract suspend fun addPeer(enr:

address

SocketAddress

)

abstract fun enr():

abstract suspend fun requestNodes(distance: Int = 1, maxSecondsToWait: Long = 10):

Map

List

abstract suspend fun start():

open fun startAsync():

abstract suspend fun terminate(): Unit

open fun terminateAsync():

abstract fun find(nodeId:

interface ENRStorage

Module Contents

)

abstract fun put(nodeId:

enr

)

Unit

open fun set(enr:

)

Unit

Scraper(coroutineContext: CoroutineContext = Executors.newFixedThreadPool(100).asCoroutineDispatcher(), vertx: Vertx = Vertx.vertx(), initialENRs: List<

Module Contents

bindAddress

InetSocketAddress

listeners

List

(

List

val bindAddress: InetSocketAddress

)

Unit

maxWaitForNewPeers

Long

waitBetweenScrapes

Long

)

fun discover(maxWaitForNewPeers: Long): Deferred<Unit>

val initialENRs: List<

List

)

Unit

Module Contents

package org.apache.tuweni.devp2p.v5.encrypt

Module Contents

object AES128GCM

Module Contents

fun decrypt(privateKey:

nonce

encoded

additionalAuthenticatedData

)

fun encrypt(privateKey:

nonce

message

additionalAuthenticatedData

)

package org.apache.tuweni.discovery

Module Contents

class DNSDaemon

Module Contents

DNSDaemon(enrLink: String, listener:

seq

Long

period

Long

dnsServer

String

resolver

Resolver

)

val listeners: HashSet<

@FunctionalInterface interface DNSDaemonListener

Module Contents

abstract fun newRecords(seq: Long, records: List<

fun readDNSEntry(serialized: String):

)

Unit

interface DNSEntry

Module Contents

DNSResolver(dnsServer: String? = null, seq: Long = 0, resolver: Resolver = SimpleResolver(dnsServer))

class DNSResolver

Module Contents

fun collectAll(enrLink: String): List<

fun resolveRecord(domainName: String):

fun resolveRecordRaw(domainName: String): String?

var seq: Long

fun visitTree(enrLink: String, visitor:

DNSVisitor

)

Unit

interface DNSVisitor

Module Contents

abstract fun visit(enr:

package org.apache.tuweni.eth

)

Boolean

Module Contents

Module Contents

balance

storageRoot

codeHash

)

balance

storageRoot

codeHash

version

Int

)

)

fun getStorageRoot():

fun getVersion(): Int

Module Contents

)

static fun fromPublicKey(publicKey: PublicKey!):

static fun fromPublicKeyBytes(bytes:

)

Module Contents

body

)

)

)

BlockBody(transactions: MutableList<

)

Unit

class BlockBody

Module Contents

ommers

MutableList

)

)

fun getOmmers(): MutableList<

)

BlockHeader(@Nullable parentHash:

)

Unit

class BlockHeader

Module Contents

ommersHash

coinbase

stateRoot

transactionsRoot

receiptsRoot

logsBloom

difficulty

number

gasLimit

gasUsed

timestamp

Instant

extraData

mixHash

nonce

)

@Nullable fun getParentHash():

)

fun getReceiptsRoot():

fun getTimestamp(): Instant!

fun getTransactionsRoot():

)

open class EthJsonModule : SimpleModule

Module Contents

EthJsonModule()

class Hash :

DelegatingBytes32

Module Contents

)

)

static fun hash(value:

)

Module Contents

data

topics

MutableList

)

fun getTopics(): MutableList<

static fun readFrom(in:

)

)

Unit

class LogsBloomFilter

Module Contents

LogsBloomFilter()

LogsBloomFilter(data:

static fun compute(logs: MutableCollection<

)

)

)

Unit

fun insertLog(log:

static fun readFrom(input:

)

Unit

)

Module Contents

gasPrice

gasLimit

@Nullable

value

payload

keyPair

KeyPair

)

gasPrice

gasLimit

@Nullable

value

payload

keyPair

KeyPair

@Nullable

chainId

Int

)

gasPrice

gasLimit

@Nullable

value

payload

@Nullable

chainId

Int

signature

Signature

)

@Nullable fun extractPublicKey(): PublicKey?

)

lenient

Boolean

)

@Nullable fun getSender():

fun getChainId(): Int!

fun getSignature(): Signature!

@Nullable fun getTo():

fun isContractCreation(): Boolean

)

static fun signatureData(nonce:

gasPrice

gasLimit

@Nullable

value

payload

@Nullable

chainId

Int

)

TransactionReceipt(stateRoot:

)

Unit

class TransactionReceipt

Module Contents

cumulativeGasUsed

Long

bloomFilter

logs

MutableList

TransactionReceipt(status: Int, cumulativeGasUsed: Long, bloomFilter:

)

logs

MutableList

)

)

fun getBloomFilter():

fun getCumulativeGasUsed(): Long

fun getLogs(): MutableList<

fun getStatus(): Int!

fun isValid(): Boolean

)

package org.apache.tuweni.eth.genesis

)

Unit

Module Contents

open class GenesisFile

Module Contents

open fun getAllocations(): MutableMap<

open fun getChainId(): Int

open fun getForks(): MutableList<Long!>!

open static fun read(contents: ByteArray!):

open fun toBlock():

package org.apache.tuweni.eth.repository

Module Contents

class BlockchainIndex :

BlockchainIndex(indexWriter: IndexWriter)

BlockchainIndexReader

Module Contents

fun chainHeadTotalDifficulty():

value

)

List

value

Long

)

List

value

)

List

value

)

List

value

)

List

value

)

List

value

)

List

value

Int

)

List

value

Long

)

List

value

)

List

value

)

List

value

)

List

value

)

List

fun findByBlockHashAndIndex(blockHash:

index

Int

)

fun findByHashOrNumber(hashOrNumber:

)

List

)

)

minValue

maxValue

)

List

minValue

maxValue

)

List

fun index(indexer: (

fun indexBlockHeader(blockHeader:

)

Unit

)

Unit

fun indexTransaction(transaction:

)

Unit

fun indexTransactionReceipt(txReceipt:

)

Unit

txIndex

Int

txHash

blockHash

fun totalDifficulty(hash:

)

Unit

)

interface BlockchainIndexReader

Module Contents

abstract fun chainHeadTotalDifficulty():

value

)

List

value

Long

)

List

value

)

List

value

)

List

value

)

List

value

)

List

value

)

List

value

Int

)

List

value

Long

)

List

value

)

List

value

)

List

value

)

List

value

)

List

abstract fun findByBlockHashAndIndex(blockHash:

index

Int

)

abstract fun findByHashOrNumber(hashOrNumber:

)

List

)

)

minValue

maxValue

)

List

minValue

maxValue

)

List

abstract fun totalDifficulty(hash:

)

interface BlockchainIndexWriter

Module Contents

abstract fun indexBlockHeader(blockHeader:

abstract fun indexTransaction(transaction:

)

Unit

abstract fun indexTransactionReceipt(txReceipt:

)

Unit

txIndex

Int

txHash

blockHash

class BlockchainRepository

)

Unit

Module Contents

BlockchainRepository(chainMetadata:

blockBodyStore

blockHeaderStore

transactionReceiptStore

transactionStore

stateStore

blockchainIndex

)

suspend fun accountsExists(address:

)

Boolean

fun findBlockByHashOrNumber(blockNumberOrBlockHash:

)

List

fun findBlocksByParentHash(parentHash:

)

List

suspend fun getAccount(address:

)

suspend fun getAccountCode(address:

)

suspend fun getAccountStoreValue(address:

key

)

suspend fun hasBlockBody(blockHash:

suspend fun hasBlockHeader(blockHash:

)

Boolean

suspend fun init(blockBodyStore:

)

Boolean

blockHeaderStore

chainMetadata

transactionReceiptsStore

transactionStore

stateStore

blockchainIndex

genesisBlock

)

suspend fun retrieveBlock(blockHash:

)

suspend fun retrieveBlockBody(blockHash:

)

suspend fun retrieveBlockBodyBytes(blockHash:

)

suspend fun retrieveBlockHeader(blockHash:

)

suspend fun retrieveBlockHeaderBytes(blockHash:

)

suspend fun retrieveChainHead():

suspend fun retrieveChainHeadHeader():

suspend fun retrieveGenesisBlock():

suspend fun retrieveNodeData(hashes: List<

)

List

suspend fun retrieveTransactionReceipt(blockHash:

index

Int

)

suspend fun retrieveTransactionReceipt(txHash:

)

suspend fun retrieveTransactionReceipts(blockHash:

)

List

suspend fun storeAccount(address:

account

suspend fun storeBlock(block:

)

Unit

suspend fun storeBlockBody(blockHash:

)

Unit

blockBody

suspend fun storeBlockHeader(:

)

Unit

suspend fun storeCode(code:

)

Unit

suspend fun storeNodeData(hash:

)

Unit

bytes

suspend fun storeTransaction(transaction:

)

Unit

suspend fun storeTransactionReceipt(transactionReceipt:

)

Unit

txIndex

Int

txHash

blockHash

enum class BlockHeaderFields

)

Unit

Module Contents

COINBASE

DIFFICULTY

EXTRA_DATA

class MemoryTransactionPool :

suspend fun add(transaction:

Module Contents

MemoryTransactionPool()

suspend fun contains(hash:

)

Unit

interface TransactionPool

)

Boolean

suspend fun get(hash:

)

Module Contents

abstract suspend fun add(transaction:

abstract suspend fun contains(hash:

)

Unit

)

Boolean

)

enum class TransactionReceiptFields

Module Contents

BLOCK_HASH

BLOOM_FILTER

CUMULATIVE_GAS_USED

package org.apache.tuweni.ethash

Module Contents

open class EthHash

Module Contents

EthHash()

static var ACCESSES: Int

static var CACHE_BYTES_GROWTH: Long

static var CACHE_BYTES_INIT: Long

static var CACHE_MULTIPLIER: Int

static var CACHE_ROUNDS: Int

open static fun calcDatasetItem(cache: Array<

index

)

static var DATASET_BYTES_GROWTH: Long

static var DATASET_BYTES_INIT: Long

static var DATASET_PARENTS: Int

open static fun epoch(block: Long): Long

static var EPOCH_LENGTH: Int

static var FNV_PRIME: Int

open static fun getCacheSize(block_number: Long): Int

open static fun getFullSize(block_number: Long): Long

static var HASH_BYTES: Int

open static fun hashimotoLight(size: Long, cache: Array<

nonce

)

static var MIX_BYTES: Int

open static fun mkCache(cacheSize: Int, block: Long): Array<

static var WORD_BYTES: Int

package org.apache.tuweni.ethclient

Module Contents

class AppOptions

Module Contents

AppOptions()

var configPath: Path?

var help: Boolean

var web: String?

interface DataStoreConfiguration

Module Contents

abstract fun getGenesisFile(): String

abstract fun getStoragePath(): Path

class DiscoveryPeerRepository :

DiscoveryPeerRepository(repository:

Module Contents

suspend fun get(host: String, port: Int, nodeId: PublicKey):

)

Module Contents

metadataStore

String

peerRepository

suspend fun seq(seq: Long): Unit

)

suspend fun seq(): Long

interface DNSConfiguration

Module Contents

abstract fun domain(): String

abstract fun pollingPeriod(): Long

data class DNSConfigurationImpl :

DNSConfigurationImpl(name: String, peerRepository: String, domain: String, pollingPeriod: Long)

Module Contents

fun domain(): String

fun getName(): String

fun peerRepository(): String

fun pollingPeriod(): Long

class EthereumClient : CoroutineScope

Module Contents

EthereumClient(vertx: Vertx, config:

coroutineContext

CoroutineContext

)

val config:

class EthereumClientConfig

Module Contents

EthereumClientConfig(config:

)

fun createSchema():

fun dataStores(): List<

DataStoreConfiguration

fun dnsClients(): List<

fun empty():

fun fromFile(path: Path?):

fun fromString(config: String):

fun genesisFiles(): List<

GenesisFileConfiguration

fun peerRepositories(): List<

PeerRepositoryConfiguration

fun rlpxServices(): List<

RLPxServiceConfiguration

fun toToml(): String!

interface GenesisFileConfiguration

Module Contents

abstract fun genesisFile():

fun main(args: Array<String>): Unit

interface PeerRepositoryConfiguration

Module Contents

interface RLPxServiceConfiguration

Module Contents

abstract fun clientName(): String

abstract fun repository(): String

class WireConnectionPeerRepositoryAdapter :

WireConnectionPeerRepositoryAdapter(peerRepository:

Module Contents

)

fun add(wireConnection:

fun addConnectionListener(listener: Listener): Unit

)

String

fun addDisconnectionListener(listener: Listener): Unit

fun asIterable(): Iterable<

fun asIterable(identifier:

package org.apache.tuweni.ethclientui

)

Iterable

Module Contents

@Path("config") class ConfigurationService

Module Contents

ConfigurationService()

var context: ServletContext?

@GET @Produces(["text/plain"]) fun get(): String

class UI

Module Contents

UI(port: Int = 0, networkInterface: String = "127.0.0.1", path: String = "/", client:

)

val networkInterface: String

package org.apache.tuweni.ethstats

Module Contents

class BlockStats

Module Contents

BlockStats(blockNumber:

hash

parentHash

timestamp

Long

miner

gasUsed

Long

gasLimit

Long

difficulty

totalDifficulty

transactions

MutableList

transactionsRoot

stateRoot

uncles

MutableList

fun getBlockNumber(): Long

)

fun getDifficulty(): String!

fun getGasLimit(): Long

fun getGasUsed(): Long

fun getHash(): String!

fun getTimestamp(): Long

fun getTotalDifficulty(): String!

fun getTransactionsRoot(): String!

fun getUncles(): MutableList<

class EthStatsReporter

Module Contents

fun sendHistoryResponse(blocks: MutableList<

timeSupplier

Supplier

Long

)

fun sendNewHead(newBlockStats:

)

Unit

fun sendNewNodeStats(nodeStats:

)

Unit

NodeStats

)

Unit

fun sendNewPendingTransactionCount(txCount: Int): Unit

Module Contents

NodeStats(active: Boolean, syncing: Boolean, mining: Boolean, hashrate: Int, peerCount: Int, gasPrice: Int, uptime: Int)

fun getGasPrice(): Int

fun getHashrate(): Int

fun getPeerCount(): Int

fun getUptime(): Int

fun isActive(): Boolean

fun isMining(): Boolean

fun isSyncing(): Boolean

Module Contents

)

package org.apache.tuweni.evm

Module Contents

Module Contents

class EthereumVirtualMachine

Module Contents

EthereumVirtualMachine(repository:

evmcFile

String

vmFile

String

options

Map

String

)

fun capabilities(): Int

destination

value

code

inputData

gas

gasPrice

currentCoinbase

currentNumber

Long

currentTimestamp

Long

currentGasLimit

Long

currentDifficulty

callKind

CallKind

revision

HardFork

depth

Int

)

enum class EVMExecutionStatusCode

fun version(): String

Module Contents

EVMC_ARGUMENT_OUT_OF_RANGE

EVMC_BAD_JUMP_DESTINATION

EVMC_CALL_DEPTH_EXCEEDED

EVMC_CONTRACT_VALIDATION_FAILURE

EVMC_FAILURE

EVMC_INTERNAL_ERROR

EVMC_INVALID_INSTRUCTION

EVMC_INVALID_MEMORY_ACCESS

EVMC_OUT_OF_GAS

EVMC_OUT_OF_MEMORY

EVMC_PRECOMPILE_FAILURE

EVMC_STATIC_MODE_VIOLATION

EVMC_SUCCESS

EVMC_UNDEFINED_INSTRUCTION

EVMC_WASM_TRAP

EVMC_WASM_UNREACHABLE_INSTRUCTION

data class EVMResult

Module Contents

EVMResult(statusCode:

gasLeft

Long

hostContext

)

fun fromBytes(bytes:

hostContext

)

val gasLeft: Long

val hostContext:

val statusCode:

fun fromCode(code: Int):

Module Contents

EVMC_TANGERINE_WHISTLE

class TransactionalEVMHostContext : HostContext

Module Contents

TransactionalEVMHostContext(repository:

ethereumVirtualMachine

depth

Int

sender

destination

value

code

gas

gasPrice

currentCoinbase

currentNumber

Long

currentTimestamp

Long

currentGasLimit

Long

currentDifficulty

val accountChanges: HashMap<

)

HashMap

fun accountExists(bytes: ByteArray): Boolean

val accountsToDestroy: MutableList<

val balanceChanges: HashMap<

fun call(msg: ByteBuffer): ByteBuffer

val currentDifficulty:

val currentGasLimit: Long

val currentNumber: Long

val currentTimestamp: Long

val depth: Int

val destination:

fun emitLog(address: ByteArray, data: ByteArray, dataSize: Int, topics: Array<ByteArray>, topicCount: Int): Unit

val ethereumVirtualMachine:

fun getBalance(addressBytes: ByteArray): ByteBuffer

fun getBlockHash(number: Long): ByteBuffer

fun getCode(address: ByteArray): ByteBuffer

fun getCodeHash(address: ByteArray): ByteBuffer

fun getCodeSize(address: ByteArray): Int

fun getStorage(addressBytes: ByteArray, keyBytes: ByteArray): ByteBuffer

fun getTxContext(): ByteBuffer

val logs: MutableList<

fun selfdestruct(address: ByteArray, beneficiary: ByteArray): Unit

val sender:

fun setStorage(addressBytes: ByteArray, keyBytes: ByteArray, valueBytes: ByteArray): Int

val value:

package org.apache.tuweni.faucet

Module Contents

@SpringBootApplication class FaucetApplication

Module Contents

FaucetApplication()

var authorizedOrg: String?

var banner: String?

@PostConstruct fun banner(): Unit

@PreDestroy fun close(): Unit

@Bean fun createVertx(): Vertx

@Bean(["wallet"]) fun createWallet(@Value("${wallet.path}") path: String, @Value("${wallet.password}") password: String):

@Bean fun createWebClient(): WebClient

@Bean fun oauth2UserService(rest: WebClient): OAuth2UserService<OAuth2UserRequest, OAuth2User>?

val vertx: Vertx!

@Component("htmlConfig") class HtmlConfig

Module Contents

HtmlConfig()

var maxETH: Long?

var requestMessage: String?

var title: String?

fun main(args: Array<String>): Unit

package org.apache.tuweni.faucet.controller

Module Contents

@Controller class FaucetController

Module Contents

FaucetController()

var chainId: Int?

@PostConstruct fun createClient(): Unit

var gas: Long?

var gasPrice: Long?

@GetMapping(["/"]) fun index(model: Model): String

@PostMapping(["/"]) fun send(@ModelAttribute request:

FaucetRequest

model

Model

)

String

Module Contents

FaucetRequest(addr: String?, message: String?)

var addr: String?

var message: String?

val logger: Logger!

package org.apache.tuweni.gossip

Module Contents

class GossipApp

Module Contents

static fun main(args: Array<String!>!): Unit

fun publish(message:

package org.apache.tuweni.hobbits

)

Unit

Module Contents

class HobbitsTransport : CoroutineScope

Module Contents

HobbitsTransport(vertx: Vertx, incompleteMessageHandler: (

)

Unit

coroutineContext

CoroutineContext

)

fun createHTTPEndpoint(id: String = "default", networkInterface: String = "0.0.0.0", port: Int = 9337, requestURI: String? = null, tls: Boolean = false, handler: (

fun createTCPEndpoint(id: String = "default", networkInterface: String = "0.0.0.0", port: Int = 9237, tls: Boolean = false, handler: (

)

Unit

portUpdateListener

(

Int

)

Unit

)

Unit

fun createUDPEndpoint(id: String = "default", networkInterface: String = "0.0.0.0", port: Int = 9137, handler: (

)

Unit

portUpdateListener

(

Int

)

Unit

)

Unit

fun createWSEndpoint(id: String = "default", networkInterface: String = "0.0.0.0", port: Int = 9037, requestURI: String? = null, tls: Boolean = false, handler: (

)

Unit

)

Unit

fun exceptionHandler(handler: (Throwable) -> Unit): Unit

)

Unit

portUpdateListener

(

Int

)

Unit

)

Unit

suspend fun sendMessage(message:

transport

Transport

host

String

port

Int

requestURI

String

)

Unit

Message(version: Int = 3, protocol:

class Message

Module Contents

headers

body

)

@JvmStatic fun readMessage(message:

)

class Relayer : CoroutineScope

val version: Int

enum class Protocol

Module Contents

val code: Byte

fun fromByte(b: Byte):

Module Contents

Relayer(vertx: Vertx, bind: String, to: String, interceptor: (

)

Unit

coroutineContext

CoroutineContext

)

package org.apache.tuweni.io

Module Contents

Module Contents

class Base32

Module Contents

static fun decode(b32: String!):

static fun decodeBytes(b32: String!): ByteArray!

)

String

static fun decode(b58: String!):

class Base58

Module Contents

static fun decodeBytes(b58: String!): ByteArray!

)

String

class Base64

Module Contents

)

String

class Base64URLSafe

Module Contents

)

String

@FunctionalInterface interface IOConsumer<T : Any!>

Module Contents

abstract fun accept(t: T): Unit

class Resources

Module Contents

@MustBeClosed static fun find(glob: String!): Stream<URL!>!

@MustBeClosed static fun find(@Nullable classLoader: ClassLoader?, glob: String!): Stream<URL!>!

class Streams

Module Contents

static fun <T : Any!> enumerationStream(enumeration: Enumeration<T>!): Stream<T>!

package org.apache.tuweni.io.file

Module Contents

class Files

Module Contents

static fun atomicReplace(path: Path!, bytes: ByteArray!): Unit

static fun atomicReplace(path: Path!, fn:

static fun atomicReplace(path: Path!, charset: Charset!, fn:

Writer

)

Unit

static fun copyResource(resourceName: String!, destination: Path!, vararg options: OpenOption!): Path!

Writer

)

Unit

static fun copyResource(classloader: ClassLoader!, resourceName: String!, destination: Path!, vararg options: OpenOption!): Path!

static fun copyResource(resourceName: String!, out: OutputStream!): Long

static fun copyResource(classloader: ClassLoader!, resourceName: String!, out: OutputStream!): Long

static fun createFileIfMissing(path: Path!, vararg attrs: FileAttribute<*>!): Boolean

static fun deleteRecursively(directory: Path!): Unit

package org.apache.tuweni.jsonrpc

Module Contents

class ClientRequestException : RuntimeException

Module Contents

ClientRequestException(message: String)

class JSONRPCClient : Closeable

Module Contents

JSONRPCClient(vertx: Vertx, serverPort: Int, serverHost: String)

val client: HttpClient!

suspend fun getBalance_latest(address:

)

suspend fun getTransactionCount_latest(address:

)

suspend fun sendRawTransaction(tx:

package org.apache.tuweni.junit

)

String

val serverHost: String

val serverPort: Int

val logger: Logger!

val mapper: ObjectMapper

Module Contents

open class BouncyCastleExtension : BeforeAllCallback

Module Contents

BouncyCastleExtension()

open fun beforeAll(context: ExtensionContext!): Unit

@Target([AnnotationTarget.VALUE_PARAMETER]) class LuceneIndex

Module Contents

LuceneIndex()

@Target([AnnotationTarget.VALUE_PARAMETER]) class LuceneIndexWriter

Module Contents

LuceneIndexWriter()

open class LuceneIndexWriterExtension : ParameterResolver, AfterAllCallback

Module Contents

LuceneIndexWriterExtension()

open fun afterAll(context: ExtensionContext!): Unit

open fun resolveParameter(parameterContext: ParameterContext!, extensionContext: ExtensionContext!): Any!

open fun supportsParameter(parameterContext: ParameterContext!, extensionContext: ExtensionContext!): Boolean

@Target([AnnotationTarget.VALUE_PARAMETER]) class RedisPort

Module Contents

RedisPort()

class RedisServerExtension : ParameterResolver, AfterAllCallback

Module Contents

RedisServerExtension()

fun resolveParameter(parameterContext: ParameterContext!, extensionContext: ExtensionContext!): Any!

fun supportsParameter(parameterContext: ParameterContext!, extensionContext: ExtensionContext!): Boolean

@Target([AnnotationTarget.VALUE_PARAMETER]) class TempDirectory

Module Contents

TempDirectory()

class TempDirectoryExtension : ParameterResolver, AfterAllCallback

Module Contents

TempDirectoryExtension()

fun resolveParameter(parameterContext: ParameterContext!, extensionContext: ExtensionContext!): Any!

fun supportsParameter(parameterContext: ParameterContext!, extensionContext: ExtensionContext!): Boolean

open class VertxExtension : ParameterResolver, AfterAllCallback

Module Contents

VertxExtension()

open fun afterAll(context: ExtensionContext!): Unit

open fun resolveParameter(parameterContext: ParameterContext!, extensionContext: ExtensionContext!): Any!

open fun supportsParameter(parameterContext: ParameterContext!, extensionContext: ExtensionContext!): Boolean

@Target([AnnotationTarget.VALUE_PARAMETER]) class VertxInstance

Module Contents

VertxInstance()

package org.apache.tuweni.kademlia

Module Contents

class KademliaRoutingTable<T> : Set<T>

Module Contents

KademliaRoutingTable(selfId: ByteArray, k: Int, maxReplacements: Int = k, nodeId: (T) -> ByteArray, distanceToSelf: (T) -> Int = { nodeId(it) xorDist selfId })

fun add(node: T): T?

fun contains(element: T): Boolean

fun containsAll(elements: Collection<T>): Boolean

@JvmStatic fun <T> create(selfId: ByteArray, k: Int, nodeId: Function<T, ByteArray>, distanceToSelf: Function<T, Int>):

@JvmStatic fun <T> create(selfId: ByteArray, k: Int, maxReplacements: Int, nodeId: Function<T, ByteArray>, distanceToSelf: Function<T, Int>):

fun evict(node: T): Boolean

fun getRandom(): T

fun iterator(): Iterator<T>

fun logDistToSelf(node: T): Int

fun nearest(targetId: ByteArray, limit: Int): List<T>

fun peersOfDistance(value: Int): List<T>

infix fun ByteArray.xorDist(other: ByteArray): Int

kotlin.ByteArray

Module Contents

fun ByteArray.xorDistCmp(a: ByteArray, b: ByteArray): Int

kotlin.collections.MutableList

Module Contents

fun <E> MutableList<E>.orderedInsert(element: E, comparison: (E, E) -> Int): Unit

package org.apache.tuweni.kv

Module Contents

class EntityManagerKeyValueStore<K, V> :

EntityManagerKeyValueStore(entityManagerProvider: () -> EntityManager, entityClass: Class<V>, idAccessor: (V) -> K, coroutineContext: CoroutineContext = Dispatchers.IO)

Module Contents

@JvmStatic fun <K, V> open(entityManagerProvider: Supplier<EntityManager>, entityClass: Class<V>, idAccessor: Function<V, K>):

EntityManagerKeyValueStore

suspend fun put(value: V): Unit

class InfinispanKeyValueStore<K, V> :

InfinispanKeyValueStore(cache: Cache<K, V>, coroutineContext: CoroutineContext = Dispatchers.IO)

Module Contents

@JvmStatic fun <K, V> open(cache: Cache<K, V>):

InfinispanKeyValueStore

interface KeyValueStore<K, V> : Closeable, CoroutineScope

Module Contents

abstract suspend fun clear(): Unit

open fun clearAsync():

abstract suspend fun containsKey(key: K): Boolean

open fun containsKeyAsync(key: K):

Boolean

abstract suspend fun keys(): Iterable<K>

open fun keysAsync():

abstract suspend fun put(key: K, value: V): Unit

Iterable

open fun putAsync(key: K, value: V):

class LevelDBKeyValueStore<K, V> :

LevelDBKeyValueStore(dbPath: Path, keySerializer: (K) ->

Module Contents

valueSerializer

(

)

keyDeserializer

(

)

valueDeserializer

(

)

options

Options

coroutineContext

CoroutineContext

)

@JvmStatic fun <K, V> open(dbPath: Path, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

)

@JvmStatic fun <K, V> open(dbPath: Path, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

options

Options

)

class MapDBKeyValueStore<K, V> :

MapDBKeyValueStore(dbPath: Path, keySerializer: (K) ->

Module Contents

valueSerializer

(

)

keyDeserializer

(

)

valueDeserializer

(

)

coroutineContext

CoroutineContext

)

@JvmStatic fun <K, V> open(dbPath: Path, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

)

class MapKeyValueStore<K, V> :

MapKeyValueStore(map: MutableMap<K, V> = HashMap(), coroutineContext: CoroutineContext = Dispatchers.IO)

Module Contents

@JvmStatic fun <K, V> open():

@JvmStatic fun <K, V> open(map: MutableMap<K, V>):

class ProxyKeyValueStore<K, V, E, R> :

ProxyKeyValueStore(store:

Module Contents

unproxyKey

(

)

proxyKey

(

)

unproxyValue

(

)

proxyValue

(

)

coroutineContext

CoroutineContext

)

@JvmStatic fun <K, V, E, R> open(store:

unproxyKey

Function

proxyKey

Function

unproxyValue

Function

proxyValue

BiFunction

)

ProxyKeyValueStore

class RedisKeyValueStore<K, V> :

RedisKeyValueStore(port: Int = 6379, address: InetAddress = InetAddress.getLoopbackAddress(), keySerializer: (K) ->

Module Contents

valueSerializer

(

)

keyDeserializer

(

)

valueDeserializer

(

RedisKeyValueStore(uri: String, keySerializer: (K) ->

)

valueSerializer

(

)

keyDeserializer

(

)

valueDeserializer

(

)

coroutineContext

CoroutineContext

)

@JvmStatic fun codec(): RedisCodec<

@JvmStatic fun open(uri: String):

@JvmStatic fun <K, V> open(uri: String, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

)

@JvmStatic fun <K, V> open(port: Int, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

)

@JvmStatic fun <K, V> open(address: InetAddress, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

)

@JvmStatic fun <K, V> open(port: Int, address: InetAddress, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

)

class RocksDBKeyValueStore<K, V> :

RocksDBKeyValueStore(dbPath: Path, keySerializer: (K) ->

Module Contents

valueSerializer

(

)

keyDeserializer

(

)

valueDeserializer

(

)

options

Options

coroutineContext

CoroutineContext

)

@JvmStatic fun <K, V> open(dbPath: Path, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

)

@JvmStatic fun <K, V> open(dbPath: Path, keySerializer: Function<K,

valueSerializer

Function

keyDeserializer

Function

valueDeserializer

Function

options

Options

)

class SQLKeyValueStore<K, V> :

SQLKeyValueStore(jdbcurl: String, tableName: String = "store", keyColumn: String = "key", valueColumn: String = "value", keySerializer: (K) ->

Module Contents

valueSerializer

(

)

keyDeserializer

(

)

valueDeserializer

(

)

coroutineContext

CoroutineContext

)

val keyColumn: String

@JvmStatic fun <K, V> open(jdbcUrl: String, keySerializer: (K) ->

valueSerializer

(

)

keyDeserializer

(

)

valueDeserializer

(

)

@JvmStatic fun <K, V> open(jdbcUrl: String, tableName: String, keyColumn: String, valueColumn: String, keySerializer: (K) ->

valueSerializer

(

)

keyDeserializer

(

)

valueDeserializer

(

)

package org.apache.tuweni.les

val tableName: String

val valueColumn: String

Module Contents

class LESSubprotocol :

LESSubprotocol(coroutineContext: CoroutineContext = Dispatchers.Default, blockchainInfo:

Module Contents

serveHeaders

Boolean

serveChainSince

serveStateSince

flowControlBufferLimit

flowControlMaximumRequestCostTable

flowControlMinimumRateOfRecharge

repo

pendingTransactionsPool

listener

(

)

Unit

)

)

client

)

)

Boolean

package org.apache.tuweni.net.tls

Module Contents

interface FingerprintRepository

Module Contents

abstract fun addFingerprint(identifier: String!, fingerprint:

abstract fun contains(identifier: String!): Boolean

)

Unit

abstract fun contains(identifier: String!, fingerprint:

static fun certificateFingerprint(certificate: Path!): ByteArray!

)

Boolean

class TLS

Module Contents

static fun certificateFingerprint(certificate: Certificate!): ByteArray!

static fun certificateHexFingerprint(certificate: Path!): String!

static fun certificateHexFingerprint(certificate: Certificate!): String!

static fun createSelfSignedCertificateIfMissing(key: Path!, certificate: Path!): Boolean

static fun createSelfSignedCertificateIfMissing(key: Path!, certificate: Path!, commonName: String!): Boolean

static fun readPemFile(certificate: Path!): ByteArray!

class TrustManagerFactories

Module Contents

static fun recordClientFingerprints(knownClientsFile: Path!): TrustManagerFactory!

static fun recordClientFingerprints(knownClientsFile: Path!, skipCASigned: Boolean): TrustManagerFactory!

)

TrustManagerFactory

static fun recordClientFingerprints(knownClientsFile: Path!, tmf: TrustManagerFactory!): TrustManagerFactory!

skipCASigned

Boolean

)

TrustManagerFactory

static fun recordServerFingerprints(knownServersFile: Path!): TrustManagerFactory!

tmf

TrustManagerFactory

)

TrustManagerFactory

static fun recordServerFingerprints(knownServersFile: Path!, skipCASigned: Boolean): TrustManagerFactory!

)

TrustManagerFactory

static fun recordServerFingerprints(knownServersFile: Path!, tmf: TrustManagerFactory!): TrustManagerFactory!

skipCASigned

Boolean

)

TrustManagerFactory

static fun trustClientOnFirstAccess(knownClientsFile: Path!): TrustManagerFactory!

tmf

TrustManagerFactory

)

TrustManagerFactory

static fun trustClientOnFirstAccess(knownClientsFile: Path!, acceptCASigned: Boolean): TrustManagerFactory!

)

TrustManagerFactory

static fun trustClientOnFirstAccess(knownClientsFile: Path!, tmf: TrustManagerFactory!): TrustManagerFactory!

acceptCASigned

Boolean

)

TrustManagerFactory

static fun trustServerOnFirstUse(knownServersFile: Path!): TrustManagerFactory!

tmf

TrustManagerFactory

)

TrustManagerFactory

static fun trustServerOnFirstUse(knownServersFile: Path!, acceptCASigned: Boolean): TrustManagerFactory!

)

TrustManagerFactory

static fun trustServerOnFirstUse(knownServersFile: Path!, tmf: TrustManagerFactory!): TrustManagerFactory!

acceptCASigned

Boolean

)

TrustManagerFactory

static fun whitelistClients(knownClientsFile: Path!): TrustManagerFactory!

tmf

TrustManagerFactory

)

TrustManagerFactory

static fun whitelistClients(knownClientsFile: Path!, acceptCASigned: Boolean): TrustManagerFactory!

)

TrustManagerFactory

static fun whitelistClients(knownClientsFile: Path!, tmf: TrustManagerFactory!): TrustManagerFactory!

acceptCASigned

Boolean

)

TrustManagerFactory

static fun whitelistServers(knownServersFile: Path!): TrustManagerFactory!

tmf

TrustManagerFactory

)

TrustManagerFactory

static fun whitelistServers(knownServersFile: Path!, acceptCASigned: Boolean): TrustManagerFactory!

)

TrustManagerFactory

static fun whitelistServers(knownServersFile: Path!, tmf: TrustManagerFactory!): TrustManagerFactory!

acceptCASigned

Boolean

)

TrustManagerFactory

static fun recordClientFingerprints(knownClientsFile: Path!): TrustOptions!

tmf

TrustManagerFactory

)

TrustManagerFactory

class VertxTrustOptions

Module Contents

static fun recordClientFingerprints(knownClientsFile: Path!, skipCASigned: Boolean): TrustOptions!

)

TrustOptions

static fun recordClientFingerprints(knownClientsFile: Path!, tmf: TrustManagerFactory!): TrustOptions!

skipCASigned

Boolean

)

TrustOptions

static fun recordServerFingerprints(knownServersFile: Path!): TrustOptions!

tmf

TrustManagerFactory

)

TrustOptions

static fun recordServerFingerprints(knownServersFile: Path!, skipCASigned: Boolean): TrustOptions!

)

TrustOptions

static fun recordServerFingerprints(knownServersFile: Path!, tmf: TrustManagerFactory!): TrustOptions!

skipCASigned

Boolean

)

TrustOptions

static fun trustClientOnFirstAccess(knownClientsFile: Path!): TrustOptions!

tmf

TrustManagerFactory

)

TrustOptions

static fun trustClientOnFirstAccess(knownClientsFile: Path!, acceptCASigned: Boolean): TrustOptions!

)

TrustOptions

static fun trustClientOnFirstAccess(knownClientsFile: Path!, tmf: TrustManagerFactory!): TrustOptions!

acceptCASigned

Boolean

)

TrustOptions

static fun trustServerOnFirstUse(knownServersFile: Path!): TrustOptions!

tmf

TrustManagerFactory

)

TrustOptions

static fun trustServerOnFirstUse(knownServersFile: Path!, acceptCASigned: Boolean): TrustOptions!

)

TrustOptions

static fun trustServerOnFirstUse(knownServersFile: Path!, tmf: TrustManagerFactory!): TrustOptions!

acceptCASigned

Boolean

)

TrustOptions

static fun whitelistClients(knownClientsFile: Path!): TrustOptions!

tmf

TrustManagerFactory

)

TrustOptions

static fun whitelistClients(knownClientsFile: Path!, acceptCASigned: Boolean): TrustOptions!

)

TrustOptions

static fun whitelistClients(knownClientsFile: Path!, tmf: TrustManagerFactory!): TrustOptions!

acceptCASigned

Boolean

)

TrustOptions

static fun whitelistServers(knownServersFile: Path!): TrustOptions!

tmf

TrustManagerFactory

)

TrustOptions

static fun whitelistServers(knownServersFile: Path!, acceptCASigned: Boolean): TrustOptions!

)

TrustOptions

static fun whitelistServers(knownServersFile: Path!, tmf: TrustManagerFactory!): TrustOptions!

acceptCASigned

Boolean

)

TrustOptions

package org.apache.tuweni.peer.repository

tmf

TrustManagerFactory

)

TrustOptions

Module Contents

interface Connection

Module Contents

abstract fun active(): Boolean

abstract fun identity():

Module Contents

abstract fun activePeers(): List<

abstract fun id(): String

abstract fun publicKey(): PublicKey

Module Contents

abstract fun lastContacted(): Instant?

abstract fun lastDiscovered(): Instant?

abstract fun addConnection(peer:

Module Contents

identity

abstract fun markConnectionInactive(peer:

)

Unit

identity

abstract fun peerDiscoveredAt(peer:

)

Unit

abstract fun randomPeer():

time

Long

)

Unit

abstract fun storeIdentity(networkInterface: String, port: Int, publicKey: PublicKey):

abstract fun storePeer(id:

lastContacted

Instant

lastDiscovered

Instant

)

package org.apache.tuweni.peer.repository.memory

Module Contents

class MemoryPeerRepository :

Module Contents

MemoryPeerRepository()

fun addConnection(peer:

identity

val connections: ConcurrentHashMap<String,

)

Unit

val identities: HashSet<

fun markConnectionInactive(peer:

identity

fun peerDiscoveredAt(peer:

)

Unit

val peerMap: ConcurrentHashMap<

time

Long

)

Unit

fun storeIdentity(networkInterface: String, port: Int, publicKey: PublicKey):

fun storePeer(id:

lastContacted

Instant

lastDiscovered

Instant

)

package org.apache.tuweni.plumtree

Module Contents

Module Contents

fun addEager(peer:

fun considerNewPeer(peer:

)

Unit

fun eagerPushPeers(): MutableCollection<

)

Unit

fun lazyPushPeers(): MutableCollection<

fun moveToEager(peer:

)

Unit

fun moveToLazy(peer:

fun peers(): MutableList<

)

Boolean

abstract fun hash(message:

)

Unit

interface MessageHashing

Module Contents

)

interface MessageListener

Module Contents

abstract fun listen(messageBody:

abstract fun sendMessage(verb: Verb!, attributes: String!, peer:

attributes

String

)

Unit

interface MessageSender

Module Contents

hash

@Nullable

payload

interface MessageValidator

)

Unit

Module Contents

Module Contents

abstract fun validate(message:

peer

)

Boolean

abstract fun prunePeer(peer:

interface PeerPruning

Module Contents

)

Boolean

abstract fun addEager(peer:

Module Contents

abstract fun considerNewPeer(peer:

)

Unit

abstract fun eagerPushPeers(): MutableCollection<

)

Unit

abstract fun lazyPushPeers(): MutableCollection<

abstract fun moveToEager(peer:

abstract fun moveToLazy(peer:

)

Unit

abstract fun peers(): MutableList<

)

Boolean

abstract fun removePeer(peer:

)

Unit

class State

Module Contents

messageHashingFunction

messageSender

messageListener

messageValidator

peerPruningFunction

)

messageHashingFunction

messageSender

messageListener

messageValidator

peerPruningFunction

graftDelay

Long

lazyQueueInterval

Long

)

fun addPeer(peer:

fun receiveGossipMessage(peer:

)

Unit

attributes

String

message

messageHash

fun receiveGraftMessage(peer:

)

Unit

messageHash

fun receiveIHaveMessage(peer:

)

Unit

messageHash

fun receivePruneMessage(peer:

)

Unit

)

Unit

fun sendGossipMessage(attributes: String!, message:

)

Unit

)

package org.apache.tuweni.plumtree.vertx

Module Contents

class VertxGossipServer

Module Contents

VertxGossipServer(vertx: Vertx!, networkInterface: String!, port: Int, messageHashing:

MessageHashing

peerRepository

fun connectTo(host: String!, port: Int):

payloadListener

MessageListener

@Nullable

payloadValidator

MessageValidator

@Nullable

peerPruningFunction

PeerPruning

graftDelay

Int

lazyQueueInterval

Int

)

fun gossip(attributes: String!, message:

package org.apache.tuweni.progpow

)

Unit

Module Contents

class ProgPoW

Module Contents

ProgPoW()

static fun createDagCache(blockNumber: Long, datasetLookup: Function<

)

Array

static fun progPowHash(blockNumber: Long, nonce: Long, :

dag

Array

dagLookupFunction

Function

)

package org.apache.tuweni.relayer

Module Contents

class RelayerApp

Module Contents

RelayerApp(vertx: Vertx, relayer:

Relayer

)

val relayer:

Relayer

package org.apache.tuweni.rlp

Module Contents

open class EndOfRLPException :

open class InvalidRLPEncodingException :

Module Contents

EndOfRLPException()

InvalidRLPEncodingException(message: String!)

Module Contents

open class InvalidRLPTypeException :

InvalidRLPTypeException(message: String!)

Module Contents

class RLP

Module Contents

Function

)

lenient

Boolean

Function

)

)

BigInteger

lenient

Boolean

)

BigInteger

)

Int

lenient

Boolean

)

Int

Function

)

lenient

Boolean

Function

)

)

Long

lenient

Boolean

)

Long

)

String

lenient

Boolean

)

String

BiConsumer

MutableList

Any

)

MutableList

Any

lenient

Boolean

BiConsumer

MutableList

Any

)

MutableList

Any

Function

)

MutableList

lenient

Boolean

Function

)

MutableList

)

lenient

Boolean

)

)

static fun encodeBigInteger(value: BigInteger!):

static fun encodeInt(value: Int):

static fun encodeList(fn: Consumer<

)

static fun <T : Any!> encodeList(elements: MutableList<T>!, fn: BiConsumer<

)

static fun <T : ByteBuffer!> encodeListTo(buffer: T, fn: Consumer<

static fun encodeLong(value: Long):

)

static fun <T : ByteBuffer!> encodeTo(buffer: T, fn: Consumer<

static fun encodeValue(value:

)

)

static fun isList(value:

open class RLPException : RuntimeException

)

Boolean

Module Contents

RLPException(message: String!)

RLPException(cause: Throwable!)

RLPException(message: String!, cause: Throwable!)

interface RLPReader

Module Contents

abstract fun isLenient(): Boolean

abstract fun nextIsEmpty(): Boolean

abstract fun nextIsList(): Boolean

abstract fun position(): Int

open fun readBigInteger(): BigInteger!

open fun readBigInteger(lenient: Boolean): BigInteger!

open fun readByte(): Byte

open fun readByte(lenient: Boolean): Byte

open fun readInt(lenient: Boolean): Int

open fun readInt(): Int

open fun <T : Any!> readList(fn: Function<

abstract fun <T : Any!> readList(lenient: Boolean, fn: Function<

)

open fun readList(fn: BiConsumer<

)

open fun readList(lenient: Boolean, fn: BiConsumer<

MutableList

Any

)

MutableList

Any

open fun <T : Any!> readListContents(fn: Function<

MutableList

Any

)

MutableList

Any

open fun <T : Any!> readListContents(lenient: Boolean, fn: Function<

)

MutableList

open fun readLong(): Long

)

MutableList

open fun readLong(lenient: Boolean): Long

open fun readString(lenient: Boolean): String!

open fun readUInt256():

open fun readUInt256(lenient: Boolean):

open fun readValue():

abstract fun readValue(lenient: Boolean):

abstract fun remaining(): Int

open fun skipNext(): Unit

abstract fun skipNext(lenient: Boolean): Unit

interface RLPWriter

Module Contents

open fun writeBigInteger(value: BigInteger!): Unit

open fun writeByte(value: Byte): Unit

open fun writeByteArray(value: ByteArray!): Unit

open fun writeInt(value: Int): Unit

abstract fun writeList(fn: Consumer<

open fun <T : Any!> writeList(elements: MutableList<T>!, elementWriter: BiConsumer<

)

Unit

abstract fun writeLong(value: Long): Unit

)

Unit

abstract fun writeRLP(value:

)

Unit

abstract fun writeValue(value:

)

Unit

package org.apache.tuweni.rlpx

)

Unit

Module Contents

open class EthereumIESEncryptionEngine

Module Contents

EthereumIESEncryptionEngine(agree: BasicAgreement!, kdf: DerivationFunction!, mac: Mac!, commonMac: ByteArray!, cipher: BufferedBlockCipher!)

protected open fun getLengthTag(p2: ByteArray!): ByteArray!

open fun init(forEncryption: Boolean, privParam: CipherParameters!, pubParam: CipherParameters!, params: CipherParameters!): Unit

open fun processBlock(in: ByteArray!, inOff: Int, inLen: Int): ByteArray!

interface HandshakeMessage

Module Contents

abstract fun ephemeralPublicKey(): PublicKey!

abstract fun nonce():

open class InvalidMACException : RuntimeException

open class MemoryWireConnectionsRepository :

MemoryWireConnectionsRepository()

Module Contents

open fun add(wireConnection:

open fun addConnectionListener(listener: Listener!): Unit

)

String

open fun addDisconnectionListener(listener: Listener!): Unit

open fun asIterable(): MutableIterable<

open fun asIterable(identifier:

)

MutableIterable

open fun asMap(): MutableMap<String!,

open fun get(id: String!):

fun configureAfterHandshake(helloMessage:

class RLPxConnection

Module Contents

)

Unit

static fun isComplementedBy(one:

other

)

Boolean

fun readFrame(messageFrame:

)

messageConsumer

Consumer

)

Unit

fun write(message:

)

class RLPxConnectionFactory

Module Contents

RLPxConnectionFactory()

static fun createConnection(initiator: Boolean, initiatorMessage:

responderMessage

ourEphemeralPrivateKey

SecretKey

peerEphemeralPublicKey

PublicKey

initiatorNonce

responderNonce

ourPublicKey

PublicKey

peerPublicKey

PublicKey

)

static fun createHandshake(keyPair: KeyPair!, remotePublicKey: PublicKey!, initAndResponse: Function<

)

static fun generateRandomBytes32():

static fun init(keyPair: KeyPair!, remotePublicKey: PublicKey!, ephemeralKeyPair: KeyPair!, initiatorNonce:

)

static fun messageSize(msgBytes:

static fun readResponse(response:

)

Int

static fun respondToHandshake(initiatorMessageBytes:

privateKey

SecretKey

)

HandshakeMessage

keyPair

KeyPair

responseHandler

Consumer

)

RLPxMessage(messageId: Int, content:

class RLPxMessage

Module Contents

)

fun content():

abstract fun actualPort(): Int

fun messageId(): Int

interface RLPxService

Module Contents

abstract fun actualSocketAddress(): InetSocketAddress!

abstract fun addToKeepAliveList(peerPublicKey: PublicKey!): Boolean

abstract fun connectTo(peerPublicKey: PublicKey!, peerAddress: InetSocketAddress!):

abstract fun disconnect(connection:

reason

abstract fun getClient(subProtocolIdentifier:

)

Unit

)

abstract fun repository():

abstract fun send(subProtocolIdentifier:

messageType

Int

connection

message

)

Unit

abstract fun start():

abstract fun stop():

interface WireConnectionRepository

Module Contents

abstract fun add(wireConnection:

abstract fun addConnectionListener(listener: Listener!): Unit

)

String

abstract fun addDisconnectionListener(listener: Listener!): Unit

abstract fun asIterable(): MutableIterable<

abstract fun asIterable(identifier:

)

MutableIterable

@Nullable abstract fun get(id: String!):

abstract fun connectionEvent(conn:

interface Listener

Module Contents

package org.apache.tuweni.rlpx.vertx

)

Unit

Module Contents

class VertxRLPxService :

VertxRLPxService(vertx: Vertx!, listenPort: Int, networkInterface: String!, advertisedPort: Int, identityKeyPair: KeyPair!, subProtocols: MutableList<

Module Contents

VertxRLPxService(vertx: Vertx!, listenPort: Int, networkInterface: String!, advertisedPort: Int, identityKeyPair: KeyPair!, subProtocols: MutableList<

clientId

String

)

clientId

String

repository

fun actualSocketAddress(): InetSocketAddress!

)

fun actualPort(): Int

fun addToKeepAliveList(peerPublicKey: PublicKey!): Boolean

fun advertisedPort(): Int

fun connectTo(peerPublicKey: PublicKey!, peerAddress: InetSocketAddress!):

fun disconnect(connection:

disconnectReason

fun getClient(subProtocolIdentifier:

)

Unit

)

fun repository():

fun send(subProtocolIdentifier:

messageType

Int

connection

message

package org.apache.tuweni.rlpx.wire

)

Unit

Module Contents

class DefaultWireConnection :

DefaultWireConnection(nodeId:

Module Contents

peerNodeId

writer

Consumer

afterHandshakeListener

Consumer

disconnectHandler

Runnable

subprotocols

LinkedHashMap

p2pVersion

Int

clientId

String

advertisedPort

Int

ready

fun agreedSubprotocols(): MutableCollection<

peerHost

String

peerPort

Int

)

fun disconnect(reason:

fun getDisconnectReason():

)

Unit

fun getPeerHello():

fun handleConnectionStart(): Unit

fun isDisconnectReceived(): Boolean

fun isDisconnectRequested(): Boolean

fun messageReceived(message:

)

Unit

fun peerHost(): String!

fun peerPort(): Int

fun registerListener(listener: EventListener!): Unit

fun sendMessage(subProtocolIdentifier:

messageType

Int

message

)

Unit

fun sendPing():

)

Boolean

INCOMPATIBLE_DEVP2P_VERSION

class DisconnectReason

Module Contents

NULL_NODE_IDENTITY_RECEIVED

static fun valueOf(reason: Int):

class HelloMessage : WireProtocolMessage

Module Contents

fun capabilities(): MutableList<Capability!>!

fun clientId(): String!

fun messageType(): Int

fun p2pVersion(): Int

abstract fun createClient(service:

interface SubProtocol

Module Contents

)

abstract fun createHandler(service:

client

)

open fun getCapabilities(): MutableList<

abstract fun versionRange(version: Int): Int

)

Boolean

interface SubProtocolClient

interface SubProtocolHandler

Module Contents

abstract fun handle(connection:

messageType

Int

message

)

abstract fun handleNewPeerConnection(connection:

)

interface SubProtocolIdentifier

Module Contents

abstract fun name(): String!

open static fun of(name: String!, version: Int):

abstract fun version(): Int

interface WireConnection

Module Contents

abstract fun agreedSubprotocols(): MutableCollection<

abstract fun onEvent(event: Event!): Unit

class Event

Module Contents

CONNECTED

DISCONNECTED

interface EventListener

Module Contents

abstract fun getDisconnectReason():

abstract fun getPeerHello():

abstract fun isDisconnectReceived(): Boolean

abstract fun isDisconnectRequested(): Boolean

abstract fun peerHost(): String!

abstract fun peerPort(): Int

abstract fun peerPublicKey(): PublicKey!

abstract fun registerListener(listener: EventListener!): Unit

package org.apache.tuweni.scuttlebutt

)

Boolean

open fun uri(): String!

Module Contents

Module Contents

Module Contents

abstract fun curve(): Curve!

open fun curveName(): String!

abstract fun ed25519PublicKey(): PublicKey!

open static fun fromPublicKey(publicKey: PublicKey!):

open static fun fromPublicKey(publicKey: PublicKey!):

open static fun fromSecretKey(secretKey: SecretKey!):

open static fun fromSecretKey(secretKey: SecretKey!):

abstract fun publicKeyAsBase64String(): String!

open static fun randomEd25519():

open static fun randomSECP256K1():

abstract fun secp256k1PublicKey(): PublicKey!

abstract fun sign(message:

)

open fun toCanonicalForm(): String!

abstract fun verify(signature:

message

Invite(host: String!, port: Int, identity:

)

Boolean

class Invite

Module Contents

static fun fromCanonicalForm(inviteCode: String!):

seedKey

Seed

)

open class MalformedInviteCodeException : RuntimeException

Module Contents

MalformedInviteCodeException(message: String!)

package org.apache.tuweni.scuttlebutt.discovery

Module Contents

class LocalIdentity

Module Contents

LocalIdentity(ip: String!, port: String!, id:

LocalIdentity(ip: String!, port: Int, id:

)

LocalIdentity(addr: InetSocketAddress!, id:

)

)

static fun fromString(str: String!):

open class ScuttlebuttLocalDiscoveryService

Module Contents

ScuttlebuttLocalDiscoveryService(vertx: Vertx!, listenPort: Int, listenNetworkInterface: String!, multicastAddress: String!)

open fun addIdentityToBroadcastList(identity:

open fun addListener(listener: Consumer<

)

Unit

package org.apache.tuweni.scuttlebutt.handshake

)

Unit

Module Contents

class HandshakeException : RuntimeException

class SecureScuttlebuttHandshakeClient

Module Contents

static fun create(ourKeyPair: KeyPair!, networkIdentifier:

serverLongTermPublicKey

PublicKey

)

fun createHello():

fun createIdentityMessage():

SecureScuttlebuttStreamClient

fun createStream():

static fun fromInvite(networkIdentifier:

invite

)

fun readAcceptMessage(message:

)

Unit

class SecureScuttlebuttHandshakeServer

)

Unit

Module Contents

static fun create(ourKeyPair: KeyPair!, networkIdentifier:

SecureScuttlebuttHandshakeServer

)

fun createAcceptMessage():

SecureScuttlebuttStreamServer

fun readIdentityMessage(message:

)

Unit

interface SecureScuttlebuttStreamClient

)

Unit

Module Contents

abstract fun readFromServer(message:

)

abstract fun sendGoodbyeToServer():

abstract fun sendToServer(message:

)

interface SecureScuttlebuttStreamServer

Module Contents

open static fun isGoodbye(message:

abstract fun readFromClient(message:

)

Boolean

)

abstract fun sendGoodbyeToClient():

abstract fun sendToClient(message:

)

class StreamException : RuntimeException

package org.apache.tuweni.scuttlebutt.handshake.vertx

Module Contents

interface ClientHandler

Module Contents

)

Unit

interface ClientHandlerFactory<T :

Module Contents

class SecureScuttlebuttVertxClient

terminationFunction

Runnable

)

Module Contents

SecureScuttlebuttVertxClient(vertx: Vertx!, keyPair: KeyPair!, networkIdentifier:

)

class SecureScuttlebuttVertxServer

connectTo

(

port

Int

host

String

@Nullable

remotePublicKey

PublicKey

@Nullable

invite

handlerFactory

)

Module Contents

SecureScuttlebuttVertxServer(vertx: Vertx!, addr: InetSocketAddress!, keyPair: KeyPair!, networkIdentifier:

handlerFactory

)

interface ServerHandler

Module Contents

)

Unit

interface ServerHandlerFactory

Module Contents

package org.apache.tuweni.scuttlebutt.lib

terminationFunction

Runnable

)

ServerHandler

Module Contents

class FeedService

Module Contents

fun createFeedStream(streamHandler: Function<Runnable!,

)

Unit

publish

(

content

)

open static fun getLocalKeys(ssbFolder: Path!): KeyPair!

open class KeyFileLoader

Module Contents

open static fun loadKeysFromFile(secretPath: Path!): KeyPair!

open class NetworkService

Module Contents

protected NetworkService(multiplexer:

open fun createChangesStream(streamHandler: Function<Runnable!,

)

open fun generateInviteCode(validForUses: Int):

PeerStateChange

)

Unit

open fun getAllKnownPeers():

MutableList

open fun getConnectedPeers():

MutableList

open fun redeemInviteCode(invite:

)

fun makeAsyncRequest(request:

class RawRequestService

Module Contents

)

fun openStream(request:

streamFactory

Function

Runnable

open class ScuttlebuttClient

)

Unit

Module Contents

protected ScuttlebuttClient(multiplexer:

open fun getFeedService():

)

open fun getNetworkService():

NetworkService

open fun getSocialService():

SocialService

open fun rawRequestService():

RawRequestService

class ScuttlebuttClientFactory

Module Contents

static val DEFAULT_NETWORK:

static fun fromNet(host: String!, port: Int, keyPair: KeyPair!, serverPublicKey: PublicKey!):

static fun fromNetWithNetworkKey(vertx: Vertx!, host: String!, port: Int, keyPair: KeyPair!, serverPublicKey: PublicKey!, networkIdentifier:

)

static fun fromNetWithVertx(vertx: Vertx!, host: String!, port: Int, keyPair: KeyPair!, serverPublicKey: PublicKey!):

static fun withInvite(vertx: Vertx!, keyPair: KeyPair!, invite:

networkIdentifier

)

open class SocialService

Module Contents

protected SocialService(multiplexer:

feedService

open fun getFollowedBy():

)

MutableList

open fun getFollowing():

MutableList

open fun getFriends():

MutableList

open fun getOwnIdentity():

open fun getOwnProfile():

String

open fun getProfile(publicKey: String!):

open fun setDisplayName(displayName: String!):

package org.apache.tuweni.scuttlebutt.lib.model

Module Contents

open class Author

Module Contents

Author(id: String!)

open class CouldNotSerializeException : RuntimeException

Module Contents

CouldNotSerializeException(ex: IOException!)

open class FeedMessage

Module Contents

FeedMessage(key: String!, type: Optional<String!>!, value:

)

open fun getType(): Optional<String!>!

open fun getValue():

open class FeedMessageDeserializer : JsonDeserializer<

FeedMessageDeserializer()

Module Contents

open fun deserialize(jp: JsonParser!, ctxt: DeserializationContext!):

FeedValue(previous: String!, author:

open class FeedValue

Module Contents

sequence

Long

timestamp

Long

hash

String

content

JsonNode

)

open fun getAuthor():

open fun <T : Any!> getContentAs(mapper: ObjectMapper!, clazz: Class<T>!): T

open fun getContentAsJsonString(): String!

open fun getHash(): String!

open fun getPrevious(): String!

open fun getSequence(): Long

open fun getTimestamp(): Long

open class Peer

Module Contents

Peer()

Peer(address: String!, port: Int, key: String!, state: String!)

open fun getAddress(): String!

open fun getState(): String!

open fun getPort(): Int

open class PeerStateChange

Module Contents

PeerStateChange()

PeerStateChange(type: String!, peer:

)

open fun getPeer():

open fun setPeer(peer:

open fun setType(type: String!): Unit

)

Unit

open class Profile

Module Contents

Profile()

Profile(key: String!, displayName: String!)

open fun getDisplayName(): String!

interface ScuttlebuttMessageContent

Module Contents

abstract fun getType(): String!

interface StreamHandler<T : Any!>

Module Contents

abstract fun onMessage(item: T): Unit

open class UpdateNameMessage :

UpdateNameMessage(name: String!, about: String!)

Module Contents

UpdateNameMessage()

open fun getAbout(): String!

package org.apache.tuweni.scuttlebutt.lib.model.query

var name: String!

var type: String!

Module Contents

open class AboutQuery

Module Contents

AboutQuery()

AboutQuery(dest: String!, keys: MutableList<String!>!)

open fun getKeys(): MutableList<String!>!

open class AboutQueryResponse

Module Contents

AboutQueryResponse()

AboutQueryResponse(name: String!)

open class IsFollowingQuery

Module Contents

IsFollowingQuery()

IsFollowingQuery(source: String!, dest: String!)

open class IsFollowingResponse

Module Contents

IsFollowingResponse()

IsFollowingResponse(source: String!, destination: String!, following: Boolean)

open fun getDestination(): String!

open fun isFollowing(): Boolean

open class WhoAmIResponse

Module Contents

WhoAmIResponse()

WhoAmIResponse(id: String!)

package org.apache.tuweni.scuttlebutt.rpc

Module Contents

open class RPCAsyncRequest

Module Contents

RPCAsyncRequest(function:

arguments

MutableList

Any

)

open fun toEncodedRpcMessage(objectMapper: ObjectMapper!):

static fun encodeRequest(body: String!, vararg flags:

class RPCCodec

Module Contents

RPCCodec()

)

vararg

flags

)

requestNumber

Int

vararg

flags

)

requestNumber

Int

flags

Byte

)

requestNumber

Int

flagByte

Byte

)

requestNumber

Int

flagByte

Byte

vararg

flags

)

requestNumber

Int

vararg

flags

)

static fun encodeStreamEndRequest(requestNumber: Int):

RPCErrorBody(name: String!, message: String!, stack: String!)

open class RPCErrorBody

Module Contents

RPCErrorBody()

open fun getMessage(): String!

open fun getStack(): String!

open fun setMessage(message: String!): Unit

open fun setName(name: String!): Unit

open fun setStack(stack: String!): Unit

interface RPCFlag

Module Contents

open fun apply(flagsByte: Byte): Byte

class BodyType :

static fun extractBodyType(flagByte: Byte): BodyType!

Module Contents

BINARY

fun isApplied(flagByte: Byte): Boolean

Module Contents

open fun isApplied(flagsByte: Byte): Boolean

Module Contents

abstract fun value(): Int

open class RPCFunction

Module Contents

RPCFunction(namespace: MutableList<String!>!, functionName: String!)

RPCFunction(functionName: String!)

open fun asList(): MutableList<String!>!

class RPCMessage

Module Contents

RPCMessage(messageBytes:

fun <T : Any!> asJSON(objectMapper: ObjectMapper!, clazz: Class<T>!): T

)

fun asString(): String!

fun body():

fun bodyType(): BodyType!

fun getErrorBody(objectMapper: ObjectMapper!): Optional<

RPCErrorBody

fun getException(objectMapper: ObjectMapper!): Optional<

RPCRequestFailedException

fun isErrorMessage(): Boolean

fun isSuccessfulLastMessage(): Boolean

fun lastMessageOrError(): Boolean

fun requestNumber(): Int

fun rpcFlags(): Byte

fun stream(): Boolean

open class RPCRequestBody

Module Contents

RPCRequestBody(name: MutableList<String!>!, type:

RPCRequestType

args

MutableList

Any

)

open fun asBytes(objectMapper: ObjectMapper!):

open fun getArgs(): MutableList<Any!>!

open fun getName(): MutableList<String!>!

Module Contents

open class RPCResponse

Module Contents

RPCResponse(body:

open fun <T : Any!> asJSON(objectMapper: ObjectMapper!, clazz: Class<T>!): T

bodyType

BodyType

)

open fun <T : Any!> asJSON(objectMapper: ObjectMapper!, typeReference: TypeReference<T>!): T

open fun asString(): String!

open fun body():

open fun bodyType(): BodyType!

open class RPCStreamRequest

Module Contents

RPCStreamRequest(function:

arguments

MutableList

Any

)

open fun toEncodedRpcMessage(mapper: ObjectMapper!):

package org.apache.tuweni.scuttlebutt.rpc.mux

Module Contents

interface Multiplexer

Module Contents

abstract fun makeAsyncRequest(request:

)

abstract fun openStream(request:

streamFactory

Function

Runnable

)

Unit

open class RPCHandler :

RPCHandler(vertx: Vertx!, messageSender: Consumer<

Module Contents

terminationFn

Runnable

)

open fun makeAsyncRequest(request:

)

open fun openStream(request:

responseSink

Function

Runnable

open fun receivedMessage(message:

)

Unit

open fun streamClosed(): Unit

)

Unit

interface ScuttlebuttStreamHandler

Module Contents

abstract fun onMessage(message:

)

Unit

package org.apache.tuweni.scuttlebutt.rpc.mux.exceptions

Module Contents

open class ConnectionClosedException : Exception

Module Contents

ConnectionClosedException()

class RPCRequestFailedException : RuntimeException

Module Contents

RPCRequestFailedException(errorMessage: String!)

package org.apache.tuweni.ssz

Module Contents

open class EndOfSSZException :

open class InvalidSSZTypeException :

Module Contents

EndOfSSZException()

InvalidSSZTypeException(message: String!)

Module Contents

class SSZ

Module Contents

static fun decodeAddress(source:

Function

SSZReader

)

)

static fun decodeAddressList(source:

)

MutableList

static fun decodeBigIntegerList(source:

bitLength

Int

)

BigInteger

static fun decodeBoolean(source:

bitLength

Int

)

MutableList

BigInteger

static fun decodeBooleanList(source:

)

Boolean

)

MutableList

Boolean

)

MutableList

ByteArray

limit

Int

)

MutableList

ByteArray

)

limit

Int

)

)

MutableList

limit

Int

)

MutableList

static fun decodeHash(source:

hashLength

Int

)

static fun decodeHashList(source:

hashLength

Int

)

MutableList

static fun decodeInt16(source:

bitLength

Int

)

Int

static fun decodeInt16List(source:

)

Int

static fun decodeInt32(source:

)

MutableList

Int

static fun decodeInt32List(source:

)

Int

static fun decodeInt64(source:

)

MutableList

Int

static fun decodeInt64List(source:

)

Long

static fun decodeInt8(source:

)

MutableList

Long

static fun decodeInt8List(source:

)

Int

static fun decodeIntList(source:

)

MutableList

Int

bitLength

Int

)

MutableList

Int

static fun decodeLongIntList(source:

bitLength

Int

)

Long

bitLength

Int

)

MutableList

Long

)

String

limit

Int

)

String

)

MutableList

String

static fun decodeUInt(source:

limit

Int

)

MutableList

String

static fun decodeUInt16(source:

bitLength

Int

)

Int

static fun decodeUInt16List(source:

)

Int

static fun decodeUInt256(source:

)

MutableList

Int

)

static fun decodeUInt256List(source:

)

MutableList

static fun decodeUInt32(source:

static fun decodeUInt32List(source:

)

Long

static fun decodeUInt384(source:

)

MutableList

Long

)

static fun decodeUInt384List(source:

)

MutableList

static fun decodeUInt64(source:

static fun decodeUInt64List(source:

)

Long

static fun decodeUInt8(source:

)

MutableList

Long

static fun decodeUInt8List(source:

)

Int

static fun decodeUIntList(source:

)

MutableList

Int

static fun decodeULong(source:

bitLength

Int

)

MutableList

Int

static fun decodeULongIntList(source:

bitLength

Int

)

Long

static fun decodeUnsignedBigInteger(source:

bitLength

Int

)

MutableList

Long

static fun decodeUnsignedBigIntegerList(source:

bitLength

Int

)

BigInteger

bitLength

Int

)

MutableList

BigInteger

)

static fun encodeAddress(address:

)

static fun encodeAddressList(vararg elements:

)

static fun encodeAddressList(elements: MutableList<out

)

static fun encodeBigInteger(value: BigInteger!, bitLength: Int):

static fun encodeBigIntegerList(bitLength: Int, vararg elements: BigInteger!):

static fun encodeBigIntegerList(bitLength: Int, elements: MutableList<BigInteger!>!):

static fun encodeBigIntegerToByteArray(value: BigInteger!, bitLength: Int): ByteArray!

static fun encodeBoolean(value: Boolean):

static fun encodeBooleanList(vararg elements: Boolean):

static fun encodeBooleanList(elements: MutableList<Boolean!>!):

static fun encodeBytes(value:

)

static fun encodeBytesList(vararg elements:

)

static fun encodeBytesList(elements: MutableList<out

)

static fun encodeHash(hash:

)

static fun encodeHashList(vararg elements:

)

static fun encodeHashList(elements: MutableList<out

)

static fun encodeInt(value: Int, bitLength: Int):

static fun encodeInt16(value: Int):

static fun encodeInt16List(vararg elements: Int):

static fun encodeInt16List(elements: MutableList<Int!>!):

static fun encodeInt32(value: Int):

static fun encodeInt32List(vararg elements: Int):

static fun encodeInt32List(elements: MutableList<Int!>!):

static fun encodeInt64(value: Long):

static fun encodeInt64List(vararg elements: Long):

static fun encodeInt64List(elements: MutableList<Long!>!):

static fun encodeInt8(value: Int):

static fun encodeInt8List(vararg elements: Int):

static fun encodeInt8List(elements: MutableList<Int!>!):

static fun encodeIntList(bitLength: Int, vararg elements: Int):

static fun encodeIntList(bitLength: Int, elements: MutableList<Int!>!):

static fun encodeLong(value: Long, bitLength: Int):

static fun encodeLongIntList(bitLength: Int, vararg elements: Long):

static fun encodeLongIntList(bitLength: Int, elements: MutableList<Long!>!):

static fun encodeStringList(vararg elements: String!):

static fun encodeStringList(elements: MutableList<String!>!):

static fun <T : ByteBuffer!> encodeTo(buffer: T, fn: Consumer<

static fun encodeUBigInteger(value: BigInteger!, bitLength: Int):

)

static fun encodeUBigIntegerToByteArray(value: BigInteger!, bitLength: Int): ByteArray!

static fun encodeUInt(value: Int, bitLength: Int):

static fun encodeUInt16(value: Int):

static fun encodeUInt16List(vararg elements: Int):

static fun encodeUInt16List(elements: MutableList<Int!>!):

static fun encodeUInt256(value:

)

static fun encodeUInt256List(vararg elements:

)

static fun encodeUInt256List(elements: MutableList<

)

static fun encodeUInt32(value: Long):

static fun encodeUInt32List(vararg elements: Long):

static fun encodeUInt32List(elements: MutableList<Long!>!):

static fun encodeUInt384(value:

)

static fun encodeUInt384List(vararg elements:

)

static fun encodeUInt384List(elements: MutableList<

)

static fun encodeUInt64(value: Long):

static fun encodeUInt64List(vararg elements: Long):

static fun encodeUInt64List(elements: MutableList<Long!>!):

static fun encodeUInt8(value: Int):

static fun encodeUInt8List(vararg elements: Int):

static fun encodeUInt8List(elements: MutableList<Int!>!):

static fun encodeUIntList(bitLength: Int, vararg elements: Int):

static fun encodeUIntList(bitLength: Int, elements: MutableList<Int!>!):

static fun encodeULong(value: Long, bitLength: Int):

static fun encodeULongIntList(bitLength: Int, vararg elements: Long):

static fun encodeULongIntList(bitLength: Int, elements: MutableList<Long!>!):

static fun hashTreeRoot(vararg bytes:

)

open class SSZException : RuntimeException

Module Contents

SSZException(message: String!)

SSZException(cause: Throwable!)

SSZException(message: String!, cause: Throwable!)

interface SSZReader

Module Contents

abstract fun readAddress():

abstract fun readAddressList(): MutableList<

abstract fun readBigInteger(bitLength: Int): BigInteger!

abstract fun readBigIntegerList(bitLength: Int): MutableList<BigInteger!>!

open fun readBoolean(): Boolean

abstract fun readBooleanList(): MutableList<Boolean!>!

open fun readByteArray(limit: Int): ByteArray!

open fun readByteArrayList(): MutableList<ByteArray!>!

open fun readByteArrayList(limit: Int): MutableList<ByteArray!>!

open fun readBytes():

abstract fun readBytes(limit: Int):

open fun readBytesList(): MutableList<

abstract fun readBytesList(limit: Int): MutableList<

open fun readFixedByteArray(byteLength: Int, limit: Int): ByteArray!

open fun readFixedBytes(byteLength: Int):

abstract fun readFixedBytes(byteLength: Int, limit: Int):

abstract fun readFixedBytesList(byteLength: Int, limit: Int): MutableList<

open fun readFixedBytesList(byteLength: Int): MutableList<

abstract fun readFixedBytesVector(listSize: Int, byteLength: Int, limit: Int): MutableList<

open fun readFixedBytesVector(listSize: Int, byteLength: Int): MutableList<

abstract fun readHash(hashLength: Int):

abstract fun readHashList(hashLength: Int): MutableList<

abstract fun readInt(bitLength: Int): Int

open fun readInt16(): Int

open fun readInt16List(): MutableList<Int!>!

open fun readInt32(): Int

open fun readInt32List(): MutableList<Int!>!

open fun readInt64(): Long

open fun readInt64List(): MutableList<Long!>!

open fun readInt8(): Int

open fun readInt8List(): MutableList<Int!>!

abstract fun readIntList(bitLength: Int): MutableList<Int!>!

abstract fun readLong(bitLength: Int): Long

abstract fun readLongIntList(bitLength: Int): MutableList<Long!>!

open fun readString(limit: Int): String!

open fun readStringList(): MutableList<String!>!

abstract fun readStringList(limit: Int): MutableList<String!>!

open fun readUInt(bitLength: Int): Int

open fun readUInt16(): Int

open fun readUInt16List(): MutableList<Int!>!

abstract fun readUInt256():

abstract fun readUInt256List(): MutableList<

open fun readUInt32(): Long

open fun readUInt32List(): MutableList<Long!>!

abstract fun readUInt384():

abstract fun readUInt384List(): MutableList<

open fun readUInt64(): Long

open fun readUInt64List(): MutableList<Long!>!

open fun readUInt8(): Int

open fun readUInt8List(): MutableList<Int!>!

open fun readUIntList(bitLength: Int): MutableList<Int!>!

open fun readULong(bitLength: Int): Long

open fun readULongIntList(bitLength: Int): MutableList<Long!>!

abstract fun readUnsignedBigInteger(bitLength: Int): BigInteger!

abstract fun readUnsignedBigIntegerList(bitLength: Int): MutableList<BigInteger!>!

open fun readVector(listSize: Long): MutableList<

abstract fun readVector(listSize: Long, limit: Int): MutableList<

open fun writeAddress(address:

interface SSZWriter

Module Contents

open fun writeAddressList(vararg elements:

)

Unit

open fun writeAddressList(elements: MutableList<out

)

Unit

open fun writeBigInteger(value: BigInteger!, bitLength: Int): Unit

)

Unit

open fun writeBigIntegerList(bitLength: Int, vararg elements: BigInteger!): Unit

open fun writeBigIntegerList(bitLength: Int, elements: MutableList<BigInteger!>!): Unit

open fun writeBoolean(value: Boolean): Unit

open fun writeBooleanList(vararg elements: Boolean): Unit

open fun writeBooleanList(elements: MutableList<Boolean!>!): Unit

open fun writeBytes(value:

open fun writeBytes(value: ByteArray!): Unit

)

Unit

open fun writeBytesList(vararg elements:

open fun writeBytesList(elements: MutableList<out

)

Unit

open fun writeFixedBytes(value:

)

Unit

open fun writeFixedBytesList(elements: MutableList<out

)

Unit

open fun writeFixedBytesVector(elements: MutableList<out

)

Unit

)

Unit

open fun writeHash(hash:

open fun writeHashList(vararg elements:

)

Unit

open fun writeHashList(elements: MutableList<out

)

Unit

open fun writeInt(value: Int, bitLength: Int): Unit

)

Unit

open fun writeInt16(value: Int): Unit

open fun writeInt16List(vararg elements: Int): Unit

open fun writeInt16List(elements: MutableList<Int!>!): Unit

open fun writeInt32(value: Int): Unit

open fun writeInt32List(vararg elements: Int): Unit

open fun writeInt32List(elements: MutableList<Int!>!): Unit

open fun writeInt64(value: Long): Unit

open fun writeInt64List(vararg elements: Long): Unit

open fun writeInt64List(elements: MutableList<Long!>!): Unit

open fun writeInt8(value: Int): Unit

open fun writeInt8List(vararg elements: Int): Unit

open fun writeInt8List(elements: MutableList<Int!>!): Unit

open fun writeIntList(bitLength: Int, vararg elements: Int): Unit

open fun writeIntList(bitLength: Int, elements: MutableList<Int!>!): Unit

open fun writeLong(value: Long, bitLength: Int): Unit

open fun writeLongIntList(bitLength: Int, vararg elements: Long): Unit

open fun writeLongIntList(bitLength: Int, elements: MutableList<Long!>!): Unit

abstract fun writeSSZ(value:

open fun writeSSZ(value: ByteArray!): Unit

)

Unit

open fun writeStringList(vararg elements: String!): Unit

open fun writeStringList(elements: MutableList<String!>!): Unit

open fun writeUBigInteger(value: BigInteger!, bitLength: Int): Unit

open fun writeUInt(value: Int, bitLength: Int): Unit

open fun writeUInt16(value: Int): Unit

open fun writeUInt16List(vararg elements: Int): Unit

open fun writeUInt16List(elements: MutableList<Int!>!): Unit

open fun writeUInt256List(vararg elements:

)

Unit

open fun writeUInt256List(elements: MutableList<

)

Unit

open fun writeUInt32(value: Long): Unit

)

Unit

open fun writeUInt32List(vararg elements: Long): Unit

open fun writeUInt32List(elements: MutableList<Long!>!): Unit

open fun writeUInt384(value:

open fun writeUInt384List(elements: MutableList<

)

Unit

open fun writeUInt384List(vararg elements:

)

Unit

open fun writeUInt64(value: Long): Unit

)

Unit

open fun writeUInt64List(vararg elements: Long): Unit

open fun writeUInt64List(elements: MutableList<Long!>!): Unit

open fun writeUInt8(value: Int): Unit

open fun writeUInt8List(vararg elements: Int): Unit

open fun writeUInt8List(elements: MutableList<Int!>!): Unit

open fun writeUIntList(bitLength: Int, vararg elements: Int): Unit

open fun writeUIntList(bitLength: Int, elements: MutableList<Int!>!): Unit

open fun writeULong(value: Long, bitLength: Int): Unit

open fun writeULongIntList(bitLength: Int, vararg elements: Long): Unit

open fun writeULongIntList(bitLength: Int, elements: MutableList<Long!>!): Unit

open fun writeVector(elements: MutableList<out

package org.apache.tuweni.toml

)

Unit

Module Contents

class Toml

Module Contents

static fun canonicalDottedKey(dottedKey: String!): String!

static fun joinKeyPath(path: MutableList<String!>!): String!

static fun parse(input: String!):

static fun parse(input: String!, version:

)

static fun parse(file: Path!):

static fun parse(file: Path!, version:

)

static fun parse(is: InputStream!):

static fun parse(is: InputStream!, version:

)

static fun parse(reader: Reader!):

static fun parse(reader: Reader!, version:

)

static fun parse(channel: ReadableByteChannel!):

static fun parse(channel: ReadableByteChannel!, version:

)

static fun parseDottedKey(dottedKey: String!): MutableList<String!>!

static fun tomlEscape(text: String!): StringBuilder!

interface TomlArray

Module Contents

abstract fun containsArrays(): Boolean

abstract fun containsBooleans(): Boolean

abstract fun containsDoubles(): Boolean

abstract fun containsLocalDates(): Boolean

abstract fun containsLocalDateTimes(): Boolean

abstract fun containsLocalTimes(): Boolean

abstract fun containsLongs(): Boolean

abstract fun containsOffsetDateTimes(): Boolean

abstract fun containsStrings(): Boolean

abstract fun containsTables(): Boolean

abstract fun get(index: Int): Any!

open fun getArray(index: Int):

open fun getBoolean(index: Int): Boolean

open fun getDouble(index: Int): Double

open fun getLocalDate(index: Int): LocalDate!

open fun getLocalDateTime(index: Int): LocalDateTime!

open fun getLocalTime(index: Int): LocalTime!

open fun getLong(index: Int): Long

open fun getOffsetDateTime(index: Int): OffsetDateTime!

open fun getString(index: Int): String!

open fun getTable(index: Int):

abstract fun inputPositionOf(index: Int):

abstract fun toList(): MutableList<Any!>!

open class TomlInvalidTypeException : RuntimeException

class TomlParseError : RuntimeException

Module Contents

fun position():

interface TomlParseResult :

Module Contents

TomlParseError

class TomlPosition

Module Contents

open fun contains(dottedKey: String!): Boolean

interface TomlTable

Module Contents

open fun contains(path: MutableList<String!>!): Boolean

open fun dottedKeySet(): MutableSet<String!>!

open fun dottedKeySet(includeTables: Boolean): MutableSet<String!>!

@Nullable open fun get(dottedKey: String!): Any?

@Nullable abstract fun get(path: MutableList<String!>!): Any?

@Nullable open fun getArray(dottedKey: String!):

@Nullable open fun getArray(path: MutableList<String!>!):

open fun getArrayOrEmpty(dottedKey: String!):

open fun getArrayOrEmpty(path: MutableList<String!>!):

@Nullable open fun getBoolean(dottedKey: String!): Boolean?

@Nullable open fun getBoolean(path: MutableList<String!>!): Boolean?

open fun getBoolean(dottedKey: String!, defaultValue: BooleanSupplier!): Boolean

open fun getBoolean(path: MutableList<String!>!, defaultValue: BooleanSupplier!): Boolean

@Nullable open fun getDouble(dottedKey: String!): Double?

@Nullable open fun getDouble(path: MutableList<String!>!): Double?

open fun getDouble(dottedKey: String!, defaultValue: DoubleSupplier!): Double

open fun getDouble(path: MutableList<String!>!, defaultValue: DoubleSupplier!): Double

@Nullable open fun getLocalDate(dottedKey: String!): LocalDate?

@Nullable open fun getLocalDate(path: MutableList<String!>!): LocalDate?

open fun getLocalDate(dottedKey: String!, defaultValue: Supplier<LocalDate!>!): LocalDate!

open fun getLocalDate(path: MutableList<String!>!, defaultValue: Supplier<LocalDate!>!): LocalDate!

@Nullable open fun getLocalDateTime(dottedKey: String!): LocalDateTime?

@Nullable open fun getLocalDateTime(path: MutableList<String!>!): LocalDateTime?

open fun getLocalDateTime(dottedKey: String!, defaultValue: Supplier<LocalDateTime!>!): LocalDateTime!

open fun getLocalDateTime(path: MutableList<String!>!, defaultValue: Supplier<LocalDateTime!>!): LocalDateTime!

@Nullable open fun getLocalTime(dottedKey: String!): LocalTime?

@Nullable open fun getLocalTime(path: MutableList<String!>!): LocalTime?

open fun getLocalTime(dottedKey: String!, defaultValue: Supplier<LocalTime!>!): LocalTime!

open fun getLocalTime(path: MutableList<String!>!, defaultValue: Supplier<LocalTime!>!): LocalTime!

@Nullable open fun getLong(dottedKey: String!): Long?

@Nullable open fun getLong(path: MutableList<String!>!): Long?

open fun getLong(dottedKey: String!, defaultValue: LongSupplier!): Long

open fun getLong(path: MutableList<String!>!, defaultValue: LongSupplier!): Long

@Nullable open fun getOffsetDateTime(dottedKey: String!): OffsetDateTime?

@Nullable open fun getOffsetDateTime(path: MutableList<String!>!): OffsetDateTime?

open fun getOffsetDateTime(dottedKey: String!, defaultValue: Supplier<OffsetDateTime!>!): OffsetDateTime!

open fun getOffsetDateTime(path: MutableList<String!>!, defaultValue: Supplier<OffsetDateTime!>!): OffsetDateTime!

@Nullable open fun getString(dottedKey: String!): String?

@Nullable open fun getString(path: MutableList<String!>!): String?

open fun getString(dottedKey: String!, defaultValue: Supplier<String!>!): String!

open fun getString(path: MutableList<String!>!, defaultValue: Supplier<String!>!): String!

@Nullable open fun getTable(dottedKey: String!):

@Nullable open fun getTable(path: MutableList<String!>!):

open fun getTableOrEmpty(dottedKey: String!):

open fun getTableOrEmpty(path: MutableList<String!>!):

@Nullable open fun inputPositionOf(dottedKey: String!):

@Nullable abstract fun inputPositionOf(path: MutableList<String!>!):

open fun isArray(dottedKey: String!): Boolean

open fun isArray(path: MutableList<String!>!): Boolean

open fun isBoolean(dottedKey: String!): Boolean

open fun isBoolean(path: MutableList<String!>!): Boolean

open fun isDouble(dottedKey: String!): Boolean

open fun isDouble(path: MutableList<String!>!): Boolean

open fun isLocalDate(dottedKey: String!): Boolean

open fun isLocalDate(path: MutableList<String!>!): Boolean

open fun isLocalDateTime(dottedKey: String!): Boolean

open fun isLocalDateTime(path: MutableList<String!>!): Boolean

open fun isLocalTime(dottedKey: String!): Boolean

open fun isLocalTime(path: MutableList<String!>!): Boolean

open fun isLong(dottedKey: String!): Boolean

open fun isLong(path: MutableList<String!>!): Boolean

open fun isOffsetDateTime(dottedKey: String!): Boolean

open fun isOffsetDateTime(path: MutableList<String!>!): Boolean

open fun isString(dottedKey: String!): Boolean

open fun isString(path: MutableList<String!>!): Boolean

open fun isTable(dottedKey: String!): Boolean

open fun isTable(path: MutableList<String!>!): Boolean

open fun keyPathSet(): MutableSet<MutableList<String!>!>!

abstract fun keyPathSet(includeTables: Boolean): MutableSet<MutableList<String!>!>!

abstract fun toMap(): MutableMap<String!, Any!>!

Module Contents

package org.apache.tuweni.toml.internal

Module Contents

open class TomlLexer : Lexer

Module Contents

TomlLexer(input: CharStream!)

protected static val _sharedContextCache: PredictionContextCache!

open fun action(_localctx: RuleContext!, ruleIndex: Int, actionIndex: Int): Unit

static val BasicStringMode: Int

static var channelNames: Array<String!>!

static val COMMENTS: Int

static val DateMode: Int

open fun getChannelNames(): Array<String!>!

open fun getModeNames(): Array<String!>!

static val InlineTableMode: Int

static val LiteralStringMode: Int

static val KeyMode: Int

static val MLBasicStringMode: Int

static val MLLiteralStringMode: Int

static var modeNames: Array<String!>!

open fun sempred(_localctx: RuleContext!, ruleIndex: Int, predIndex: Int): Boolean

static val ValueMode: Int

static val WHITESPACE: Int

open class TomlParser : Parser

Module Contents

TomlParser(input: TokenStream!)

protected static val _sharedContextCache: PredictionContextCache!

fun array(): ArrayContext!

open class ArrayContext : ParserRuleContext

Module Contents

ArrayContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun ArrayEnd(): TerminalNode!

open fun ArrayStart(): TerminalNode!

open fun arrayValues(): ArrayValuesContext!

open fun Comma(): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun arrayTable(): ArrayTableContext!

open class ArrayTableContext : ParserRuleContext

Module Contents

ArrayTableContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun ArrayTableKeyEnd(): TerminalNode!

open fun ArrayTableKeyStart(): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun arrayValue(): ArrayValueContext!

open class ArrayValueContext : ParserRuleContext

Module Contents

ArrayValueContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun arrayValues(): ArrayValuesContext!

open class ArrayValuesContext : ParserRuleContext

Module Contents

ArrayValuesContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun arrayValue(): MutableList<ArrayValueContext!>!

open fun arrayValue(i: Int): ArrayValueContext!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun basicChar(): BasicCharContext!

open class BasicCharContext : ParserRuleContext

Module Contents

BasicCharContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun basicUnescaped(): BasicUnescapedContext!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun basicString(): BasicStringContext!

open class BasicStringContext : ParserRuleContext

Module Contents

BasicStringContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun basicChar(): MutableList<BasicCharContext!>!

open fun basicChar(i: Int): BasicCharContext!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun QuotationMark(): MutableList<TerminalNode!>!

open fun QuotationMark(i: Int): TerminalNode!

fun basicUnescaped(): BasicUnescapedContext!

open class BasicUnescapedContext : ParserRuleContext

Module Contents

BasicUnescapedContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun binInt(): BinIntContext!

open class BinIntContext : ParserRuleContext

Module Contents

BinIntContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun BinaryInteger(): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun booleanValue(): BooleanValueContext!

open class BooleanValueContext : ParserRuleContext

Module Contents

BooleanValueContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun falseBool(): FalseBoolContext!

open fun trueBool(): TrueBoolContext!

fun date(): DateContext!

open class DateContext : ParserRuleContext

Module Contents

DateContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun Dash(): MutableList<TerminalNode!>!

open fun Dash(i: Int): TerminalNode!

open fun day(): DayContext!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun month(): MonthContext!

open fun year(): YearContext!

fun dateTime(): DateTimeContext!

open class DateTimeContext : ParserRuleContext

Module Contents

DateTimeContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun localDate(): LocalDateContext!

open fun localDateTime(): LocalDateTimeContext!

open fun localTime(): LocalTimeContext!

open fun offsetDateTime(): OffsetDateTimeContext!

fun day(): DayContext!

open class DayContext : ParserRuleContext

Module Contents

DayContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun decInt(): DecIntContext!

open class DecIntContext : ParserRuleContext

Module Contents

DecIntContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun DecimalInteger(): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun escaped(): EscapedContext!

open class EscapedContext : ParserRuleContext

Module Contents

EscapedContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun EscapeSequence(): TerminalNode!

open fun exitRule(listener: ParseTreeListener!): Unit

fun expression(): ExpressionContext!

open class ExpressionContext : ParserRuleContext

Module Contents

ExpressionContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun keyval(): KeyvalContext!

open fun table(): TableContext!

fun falseBool(): FalseBoolContext!

open class FalseBoolContext : ParserRuleContext

Module Contents

FalseBoolContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun FalseBoolean(): TerminalNode!

fun floatValue(): FloatValueContext!

open class FloatValueContext : ParserRuleContext

Module Contents

FloatValueContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun regularFloat(): RegularFloatContext!

open fun regularFloatInf(): RegularFloatInfContext!

open fun regularFloatNaN(): RegularFloatNaNContext!

fun hexInt(): HexIntContext!

open class HexIntContext : ParserRuleContext

Module Contents

HexIntContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun HexInteger(): TerminalNode!

open class HourContext : ParserRuleContext

fun hour(): HourContext!

Module Contents

HourContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun hourOffset(): HourOffsetContext!

open class HourOffsetContext : ParserRuleContext

Module Contents

HourOffsetContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun Dash(): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun Plus(): TerminalNode!

fun inlineTable(): InlineTableContext!

open class InlineTableContext : ParserRuleContext

Module Contents

InlineTableContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun InlineTableEnd(): TerminalNode!

open fun InlineTableStart(): TerminalNode!

open fun inlineTableValues(): InlineTableValuesContext!

fun inlineTableValues(): InlineTableValuesContext!

open class InlineTableValuesContext : ParserRuleContext

Module Contents

InlineTableValuesContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun keyval(): MutableList<KeyvalContext!>!

open fun keyval(i: Int): KeyvalContext!

fun integer(): IntegerContext!

open class IntegerContext : ParserRuleContext

Module Contents

IntegerContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun binInt(): BinIntContext!

open fun decInt(): DecIntContext!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun hexInt(): HexIntContext!

open fun octInt(): OctIntContext!

fun key(): KeyContext!

open class KeyContext : ParserRuleContext

Module Contents

KeyContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun Dot(): MutableList<TerminalNode!>!

open fun Dot(i: Int): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun simpleKey(): MutableList<SimpleKeyContext!>!

open fun simpleKey(i: Int): SimpleKeyContext!

fun keyval(): KeyvalContext!

open class KeyvalContext : ParserRuleContext

Module Contents

KeyvalContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun Equals(): TerminalNode!

open fun exitRule(listener: ParseTreeListener!): Unit

fun literalBody(): LiteralBodyContext!

open class LiteralBodyContext : ParserRuleContext

Module Contents

LiteralBodyContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun literalString(): LiteralStringContext!

open class LiteralStringContext : ParserRuleContext

Module Contents

LiteralStringContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun Apostrophe(): MutableList<TerminalNode!>!

open fun Apostrophe(i: Int): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun literalBody(): LiteralBodyContext!

fun localDate(): LocalDateContext!

open class LocalDateContext : ParserRuleContext

Module Contents

LocalDateContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun localDateTime(): LocalDateTimeContext!

open class LocalDateTimeContext : ParserRuleContext

Module Contents

LocalDateTimeContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun localTime(): LocalTimeContext!

open class LocalTimeContext : ParserRuleContext

Module Contents

LocalTimeContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun minute(): MinuteContext!

open class MinuteContext : ParserRuleContext

Module Contents

MinuteContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun minuteOffset(): MinuteOffsetContext!

open class MinuteOffsetContext : ParserRuleContext

Module Contents

MinuteOffsetContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun mlBasicChar(): MlBasicCharContext!

open class MlBasicCharContext : ParserRuleContext

Module Contents

MlBasicCharContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun mlBasicUnescaped(): MlBasicUnescapedContext!

fun mlBasicString(): MlBasicStringContext!

open class MlBasicStringContext : ParserRuleContext

Module Contents

MlBasicStringContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun mlBasicChar(): MutableList<MlBasicCharContext!>!

open fun mlBasicChar(i: Int): MlBasicCharContext!

open fun TripleQuotationMark(): MutableList<TerminalNode!>!

open fun TripleQuotationMark(i: Int): TerminalNode!

fun mlBasicUnescaped(): MlBasicUnescapedContext!

open class MlBasicUnescapedContext : ParserRuleContext

Module Contents

MlBasicUnescapedContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun NewLine(): TerminalNode!

fun mlLiteralBody(): MlLiteralBodyContext!

open class MlLiteralBodyContext : ParserRuleContext

Module Contents

MlLiteralBodyContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun mlLiteralString(): MlLiteralStringContext!

open class MlLiteralStringContext : ParserRuleContext

Module Contents

MlLiteralStringContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun mlLiteralBody(): MlLiteralBodyContext!

open fun TripleApostrophe(): MutableList<TerminalNode!>!

open fun TripleApostrophe(i: Int): TerminalNode!

fun month(): MonthContext!

open class MonthContext : ParserRuleContext

Module Contents

MonthContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun octInt(): OctIntContext!

open class OctIntContext : ParserRuleContext

Module Contents

OctIntContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun OctalInteger(): TerminalNode!

fun offsetDateTime(): OffsetDateTimeContext!

open class OffsetDateTimeContext : ParserRuleContext

Module Contents

OffsetDateTimeContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun timeOffset(): TimeOffsetContext!

fun quotedKey(): QuotedKeyContext!

open class QuotedKeyContext : ParserRuleContext

Module Contents

QuotedKeyContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun regularFloat(): RegularFloatContext!

open class RegularFloatContext : ParserRuleContext

Module Contents

RegularFloatContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun FloatingPoint(): TerminalNode!

fun regularFloatInf(): RegularFloatInfContext!

open class RegularFloatInfContext : ParserRuleContext

Module Contents

RegularFloatInfContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun FloatingPointInf(): TerminalNode!

fun regularFloatNaN(): RegularFloatNaNContext!

open class RegularFloatNaNContext : ParserRuleContext

Module Contents

RegularFloatNaNContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun FloatingPointNaN(): TerminalNode!

static val RULE_array: Int

static val RULE_arrayTable: Int

static val RULE_arrayValue: Int

static val RULE_arrayValues: Int

static val RULE_basicChar: Int

static val RULE_basicString: Int

static val RULE_basicUnescaped: Int

static val RULE_binInt: Int

static val RULE_booleanValue: Int

static val RULE_date: Int

static val RULE_dateTime: Int

static val RULE_day: Int

static val RULE_decInt: Int

static val RULE_escaped: Int

static val RULE_expression: Int

static val RULE_falseBool: Int

static val RULE_floatValue: Int

static val RULE_hexInt: Int

static val RULE_hour: Int

static val RULE_hourOffset: Int

static val RULE_inlineTable: Int

static val RULE_inlineTableValues: Int

static val RULE_integer: Int

static val RULE_key: Int

static val RULE_keyval: Int

static val RULE_literalBody: Int

static val RULE_literalString: Int

static val RULE_localDate: Int

static val RULE_localDateTime: Int

static val RULE_localTime: Int

static val RULE_minute: Int

static val RULE_minuteOffset: Int

static val RULE_mlBasicChar: Int

static val RULE_mlBasicString: Int

static val RULE_mlBasicUnescaped: Int

static val RULE_mlLiteralBody: Int

static val RULE_mlLiteralString: Int

static val RULE_month: Int

static val RULE_octInt: Int

static val RULE_offsetDateTime: Int

static val RULE_quotedKey: Int

static val RULE_regularFloat: Int

static val RULE_regularFloatInf: Int

static val RULE_regularFloatNaN: Int

static val RULE_second: Int

static val RULE_secondFraction: Int

static val RULE_simpleKey: Int

static val RULE_standardTable: Int

static val RULE_string: Int

static val RULE_table: Int

static val RULE_time: Int

static val RULE_timeOffset: Int

static val RULE_toml: Int

static val RULE_tomlKey: Int

static val RULE_trueBool: Int

static val RULE_unquotedKey: Int

static val RULE_val: Int

static val RULE_year: Int

fun second(): SecondContext!

open class SecondContext : ParserRuleContext

Module Contents

SecondContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun secondFraction(): SecondFractionContext!

open class SecondFractionContext : ParserRuleContext

Module Contents

SecondFractionContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun simpleKey(): SimpleKeyContext!

open class SimpleKeyContext : ParserRuleContext

Module Contents

SimpleKeyContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun quotedKey(): QuotedKeyContext!

open fun unquotedKey(): UnquotedKeyContext!

fun standardTable(): StandardTableContext!

open class StandardTableContext : ParserRuleContext

Module Contents

StandardTableContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun TableKeyEnd(): TerminalNode!

open fun TableKeyStart(): TerminalNode!

fun string(): StringContext!

open class StringContext : ParserRuleContext

Module Contents

StringContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun mlBasicString(): MlBasicStringContext!

open fun mlLiteralString(): MlLiteralStringContext!

fun table(): TableContext!

open class TableContext : ParserRuleContext

Module Contents

TableContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun arrayTable(): ArrayTableContext!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun standardTable(): StandardTableContext!

open class TimeContext : ParserRuleContext

fun time(): TimeContext!

Module Contents

TimeContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun Colon(): MutableList<TerminalNode!>!

open fun Colon(i: Int): TerminalNode!

open fun Dot(): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun minute(): MinuteContext!

open fun second(): SecondContext!

open fun secondFraction(): SecondFractionContext!

fun timeOffset(): TimeOffsetContext!

open class TimeOffsetContext : ParserRuleContext

Module Contents

TimeOffsetContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun Colon(): TerminalNode!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun hourOffset(): HourOffsetContext!

open fun minuteOffset(): MinuteOffsetContext!

open fun Z(): TerminalNode!

open class TomlContext : ParserRuleContext

fun toml(): TomlContext!

Module Contents

TomlContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun expression(): MutableList<ExpressionContext!>!

open fun expression(i: Int): ExpressionContext!

fun tomlKey(): TomlKeyContext!

open class TomlKeyContext : ParserRuleContext

Module Contents

TomlKeyContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

fun trueBool(): TrueBoolContext!

open class TrueBoolContext : ParserRuleContext

Module Contents

TrueBoolContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun TrueBoolean(): TerminalNode!

fun unquotedKey(): UnquotedKeyContext!

open class UnquotedKeyContext : ParserRuleContext

Module Contents

UnquotedKeyContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun UnquotedKey(): TerminalNode!

fun val(): ValContext!

open class ValContext : ParserRuleContext

Module Contents

ValContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun array(): ArrayContext!

open fun booleanValue(): BooleanValueContext!

open fun dateTime(): DateTimeContext!

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open fun floatValue(): FloatValueContext!

open fun inlineTable(): InlineTableContext!

open fun integer(): IntegerContext!

open fun string(): StringContext!

open class YearContext : ParserRuleContext

fun year(): YearContext!

Module Contents

YearContext(parent: ParserRuleContext!, invokingState: Int)

open fun <T : Any!> accept(visitor: ParseTreeVisitor<out T>!): T

open fun enterRule(listener: ParseTreeListener!): Unit

open fun exitRule(listener: ParseTreeListener!): Unit

open class TomlParserBaseListener :

TomlParserListener

Module Contents

TomlParserBaseListener()

open fun enterArray(ctx: ArrayContext!): Unit

open fun enterArrayTable(ctx: ArrayTableContext!): Unit

open fun enterArrayValue(ctx: ArrayValueContext!): Unit

open fun enterArrayValues(ctx: ArrayValuesContext!): Unit

open fun enterBasicChar(ctx: BasicCharContext!): Unit

open fun enterBasicString(ctx: BasicStringContext!): Unit

open fun enterBasicUnescaped(ctx: BasicUnescapedContext!): Unit

open fun enterBinInt(ctx: BinIntContext!): Unit

open fun enterBooleanValue(ctx: BooleanValueContext!): Unit

open fun enterDate(ctx: DateContext!): Unit

open fun enterDateTime(ctx: DateTimeContext!): Unit

open fun enterDay(ctx: DayContext!): Unit

open fun enterDecInt(ctx: DecIntContext!): Unit

open fun enterEscaped(ctx: EscapedContext!): Unit

open fun enterEveryRule(ctx: ParserRuleContext!): Unit

open fun enterExpression(ctx: ExpressionContext!): Unit

open fun enterFalseBool(ctx: FalseBoolContext!): Unit

open fun enterFloatValue(ctx: FloatValueContext!): Unit

open fun enterHexInt(ctx: HexIntContext!): Unit

open fun enterHour(ctx: HourContext!): Unit

open fun enterHourOffset(ctx: HourOffsetContext!): Unit

open fun enterInlineTable(ctx: InlineTableContext!): Unit

open fun enterInlineTableValues(ctx: InlineTableValuesContext!): Unit

open fun enterInteger(ctx: IntegerContext!): Unit

open fun enterKey(ctx: KeyContext!): Unit

open fun enterKeyval(ctx: KeyvalContext!): Unit

open fun enterLiteralBody(ctx: LiteralBodyContext!): Unit

open fun enterLiteralString(ctx: LiteralStringContext!): Unit

open fun enterLocalDate(ctx: LocalDateContext!): Unit

open fun enterLocalDateTime(ctx: LocalDateTimeContext!): Unit

open fun enterLocalTime(ctx: LocalTimeContext!): Unit

open fun enterMinute(ctx: MinuteContext!): Unit

open fun enterMinuteOffset(ctx: MinuteOffsetContext!): Unit

open fun enterMlBasicChar(ctx: MlBasicCharContext!): Unit

open fun enterMlBasicString(ctx: MlBasicStringContext!): Unit

open fun enterMlBasicUnescaped(ctx: MlBasicUnescapedContext!): Unit

open fun enterMlLiteralBody(ctx: MlLiteralBodyContext!): Unit

open fun enterMlLiteralString(ctx: MlLiteralStringContext!): Unit

open fun enterMonth(ctx: MonthContext!): Unit

open fun enterOctInt(ctx: OctIntContext!): Unit

open fun enterOffsetDateTime(ctx: OffsetDateTimeContext!): Unit

open fun enterQuotedKey(ctx: QuotedKeyContext!): Unit

open fun enterRegularFloat(ctx: RegularFloatContext!): Unit

open fun enterRegularFloatInf(ctx: RegularFloatInfContext!): Unit

open fun enterRegularFloatNaN(ctx: RegularFloatNaNContext!): Unit

open fun enterSecond(ctx: SecondContext!): Unit

open fun enterSecondFraction(ctx: SecondFractionContext!): Unit

open fun enterSimpleKey(ctx: SimpleKeyContext!): Unit

open fun enterStandardTable(ctx: StandardTableContext!): Unit

open fun enterString(ctx: StringContext!): Unit

open fun enterTable(ctx: TableContext!): Unit

open fun enterTime(ctx: TimeContext!): Unit

open fun enterTimeOffset(ctx: TimeOffsetContext!): Unit

open fun enterToml(ctx: TomlContext!): Unit

open fun enterTomlKey(ctx: TomlKeyContext!): Unit

open fun enterTrueBool(ctx: TrueBoolContext!): Unit

open fun enterUnquotedKey(ctx: UnquotedKeyContext!): Unit

open fun enterVal(ctx: ValContext!): Unit

open fun enterYear(ctx: YearContext!): Unit

open fun exitArray(ctx: ArrayContext!): Unit

open fun exitArrayTable(ctx: ArrayTableContext!): Unit

open fun exitArrayValue(ctx: ArrayValueContext!): Unit

open fun exitArrayValues(ctx: ArrayValuesContext!): Unit

open fun exitBasicChar(ctx: BasicCharContext!): Unit

open fun exitBasicString(ctx: BasicStringContext!): Unit

open fun exitBasicUnescaped(ctx: BasicUnescapedContext!): Unit

open fun exitBinInt(ctx: BinIntContext!): Unit

open fun exitBooleanValue(ctx: BooleanValueContext!): Unit

open fun exitDate(ctx: DateContext!): Unit

open fun exitDateTime(ctx: DateTimeContext!): Unit

open fun exitDay(ctx: DayContext!): Unit

open fun exitDecInt(ctx: DecIntContext!): Unit

open fun exitEscaped(ctx: EscapedContext!): Unit

open fun exitEveryRule(ctx: ParserRuleContext!): Unit

open fun exitExpression(ctx: ExpressionContext!): Unit

open fun exitFalseBool(ctx: FalseBoolContext!): Unit

open fun exitFloatValue(ctx: FloatValueContext!): Unit

open fun exitHexInt(ctx: HexIntContext!): Unit

open fun exitHour(ctx: HourContext!): Unit

open fun exitHourOffset(ctx: HourOffsetContext!): Unit

open fun exitInlineTable(ctx: InlineTableContext!): Unit

open fun exitInlineTableValues(ctx: InlineTableValuesContext!): Unit

open fun exitInteger(ctx: IntegerContext!): Unit

open fun exitKey(ctx: KeyContext!): Unit

open fun exitKeyval(ctx: KeyvalContext!): Unit

open fun exitLiteralBody(ctx: LiteralBodyContext!): Unit

open fun exitLiteralString(ctx: LiteralStringContext!): Unit

open fun exitLocalDate(ctx: LocalDateContext!): Unit

open fun exitLocalDateTime(ctx: LocalDateTimeContext!): Unit

open fun exitLocalTime(ctx: LocalTimeContext!): Unit

open fun exitMinute(ctx: MinuteContext!): Unit

open fun exitMinuteOffset(ctx: MinuteOffsetContext!): Unit

open fun exitMlBasicChar(ctx: MlBasicCharContext!): Unit

open fun exitMlBasicString(ctx: MlBasicStringContext!): Unit

open fun exitMlBasicUnescaped(ctx: MlBasicUnescapedContext!): Unit

open fun exitMlLiteralBody(ctx: MlLiteralBodyContext!): Unit

open fun exitMlLiteralString(ctx: MlLiteralStringContext!): Unit

open fun exitMonth(ctx: MonthContext!): Unit

open fun exitOctInt(ctx: OctIntContext!): Unit

open fun exitOffsetDateTime(ctx: OffsetDateTimeContext!): Unit

open fun exitQuotedKey(ctx: QuotedKeyContext!): Unit

open fun exitRegularFloat(ctx: RegularFloatContext!): Unit

open fun exitRegularFloatInf(ctx: RegularFloatInfContext!): Unit

open fun exitRegularFloatNaN(ctx: RegularFloatNaNContext!): Unit

open fun exitSecond(ctx: SecondContext!): Unit

open fun exitSecondFraction(ctx: SecondFractionContext!): Unit

open fun exitSimpleKey(ctx: SimpleKeyContext!): Unit

open fun exitStandardTable(ctx: StandardTableContext!): Unit

open fun exitString(ctx: StringContext!): Unit

open fun exitTable(ctx: TableContext!): Unit

open fun exitTime(ctx: TimeContext!): Unit

open fun exitTimeOffset(ctx: TimeOffsetContext!): Unit

open fun exitToml(ctx: TomlContext!): Unit

open fun exitTomlKey(ctx: TomlKeyContext!): Unit

open fun exitTrueBool(ctx: TrueBoolContext!): Unit

open fun exitUnquotedKey(ctx: UnquotedKeyContext!): Unit

open fun exitVal(ctx: ValContext!): Unit

open fun exitYear(ctx: YearContext!): Unit

open fun visitErrorNode(node: ErrorNode!): Unit

open fun visitTerminal(node: TerminalNode!): Unit

open class TomlParserBaseVisitor<T : Any!> : AbstractParseTreeVisitor<T>,

TomlParserVisitor

Module Contents

TomlParserBaseVisitor()

open fun visitArray(ctx: ArrayContext!): T

open fun visitArrayTable(ctx: ArrayTableContext!): T

open fun visitArrayValue(ctx: ArrayValueContext!): T

open fun visitArrayValues(ctx: ArrayValuesContext!): T

open fun visitBasicChar(ctx: BasicCharContext!): T

open fun visitBasicString(ctx: BasicStringContext!): T

open fun visitBasicUnescaped(ctx: BasicUnescapedContext!): T

open fun visitBinInt(ctx: BinIntContext!): T

open fun visitBooleanValue(ctx: BooleanValueContext!): T

open fun visitDate(ctx: DateContext!): T

open fun visitDateTime(ctx: DateTimeContext!): T

open fun visitDay(ctx: DayContext!): T

open fun visitDecInt(ctx: DecIntContext!): T

open fun visitEscaped(ctx: EscapedContext!): T

open fun visitExpression(ctx: ExpressionContext!): T

open fun visitFalseBool(ctx: FalseBoolContext!): T

open fun visitFloatValue(ctx: FloatValueContext!): T

open fun visitHexInt(ctx: HexIntContext!): T

open fun visitHour(ctx: HourContext!): T

open fun visitHourOffset(ctx: HourOffsetContext!): T

open fun visitInlineTable(ctx: InlineTableContext!): T

open fun visitInlineTableValues(ctx: InlineTableValuesContext!): T

open fun visitInteger(ctx: IntegerContext!): T

open fun visitKey(ctx: KeyContext!): T

open fun visitKeyval(ctx: KeyvalContext!): T

open fun visitLiteralBody(ctx: LiteralBodyContext!): T

open fun visitLiteralString(ctx: LiteralStringContext!): T

open fun visitLocalDate(ctx: LocalDateContext!): T

open fun visitLocalDateTime(ctx: LocalDateTimeContext!): T

open fun visitLocalTime(ctx: LocalTimeContext!): T

open fun visitMinute(ctx: MinuteContext!): T

open fun visitMinuteOffset(ctx: MinuteOffsetContext!): T

open fun visitMlBasicChar(ctx: MlBasicCharContext!): T

open fun visitMlBasicString(ctx: MlBasicStringContext!): T

open fun visitMlBasicUnescaped(ctx: MlBasicUnescapedContext!): T

open fun visitMlLiteralBody(ctx: MlLiteralBodyContext!): T

open fun visitMlLiteralString(ctx: MlLiteralStringContext!): T

open fun visitMonth(ctx: MonthContext!): T

open fun visitOctInt(ctx: OctIntContext!): T

open fun visitOffsetDateTime(ctx: OffsetDateTimeContext!): T

open fun visitQuotedKey(ctx: QuotedKeyContext!): T

open fun visitRegularFloat(ctx: RegularFloatContext!): T

open fun visitRegularFloatInf(ctx: RegularFloatInfContext!): T

open fun visitRegularFloatNaN(ctx: RegularFloatNaNContext!): T

open fun visitSecond(ctx: SecondContext!): T

open fun visitSecondFraction(ctx: SecondFractionContext!): T

open fun visitSimpleKey(ctx: SimpleKeyContext!): T

open fun visitStandardTable(ctx: StandardTableContext!): T

open fun visitString(ctx: StringContext!): T

open fun visitTable(ctx: TableContext!): T

open fun visitTime(ctx: TimeContext!): T

open fun visitTimeOffset(ctx: TimeOffsetContext!): T

open fun visitToml(ctx: TomlContext!): T

open fun visitTomlKey(ctx: TomlKeyContext!): T

open fun visitTrueBool(ctx: TrueBoolContext!): T

open fun visitUnquotedKey(ctx: UnquotedKeyContext!): T

open fun visitVal(ctx: ValContext!): T

open fun visitYear(ctx: YearContext!): T

interface TomlParserListener : ParseTreeListener

Module Contents

abstract fun enterArray(ctx: ArrayContext!): Unit

abstract fun enterArrayTable(ctx: ArrayTableContext!): Unit

abstract fun enterArrayValue(ctx: ArrayValueContext!): Unit

abstract fun enterArrayValues(ctx: ArrayValuesContext!): Unit

abstract fun enterBasicChar(ctx: BasicCharContext!): Unit

abstract fun enterBasicString(ctx: BasicStringContext!): Unit

abstract fun enterBasicUnescaped(ctx: BasicUnescapedContext!): Unit

abstract fun enterBinInt(ctx: BinIntContext!): Unit

abstract fun enterBooleanValue(ctx: BooleanValueContext!): Unit

abstract fun enterDate(ctx: DateContext!): Unit

abstract fun enterDateTime(ctx: DateTimeContext!): Unit

abstract fun enterDay(ctx: DayContext!): Unit

abstract fun enterDecInt(ctx: DecIntContext!): Unit

abstract fun enterEscaped(ctx: EscapedContext!): Unit

abstract fun enterExpression(ctx: ExpressionContext!): Unit

abstract fun enterFalseBool(ctx: FalseBoolContext!): Unit

abstract fun enterFloatValue(ctx: FloatValueContext!): Unit

abstract fun enterHexInt(ctx: HexIntContext!): Unit

abstract fun enterHour(ctx: HourContext!): Unit

abstract fun enterHourOffset(ctx: HourOffsetContext!): Unit

abstract fun enterInlineTable(ctx: InlineTableContext!): Unit

abstract fun enterInlineTableValues(ctx: InlineTableValuesContext!): Unit

abstract fun enterInteger(ctx: IntegerContext!): Unit

abstract fun enterKey(ctx: KeyContext!): Unit

abstract fun enterKeyval(ctx: KeyvalContext!): Unit

abstract fun enterLiteralBody(ctx: LiteralBodyContext!): Unit

abstract fun enterLiteralString(ctx: LiteralStringContext!): Unit

abstract fun enterLocalDate(ctx: LocalDateContext!): Unit

abstract fun enterLocalDateTime(ctx: LocalDateTimeContext!): Unit

abstract fun enterLocalTime(ctx: LocalTimeContext!): Unit

abstract fun enterMinute(ctx: MinuteContext!): Unit

abstract fun enterMinuteOffset(ctx: MinuteOffsetContext!): Unit

abstract fun enterMlBasicChar(ctx: MlBasicCharContext!): Unit

abstract fun enterMlBasicString(ctx: MlBasicStringContext!): Unit

abstract fun enterMlBasicUnescaped(ctx: MlBasicUnescapedContext!): Unit

abstract fun enterMlLiteralBody(ctx: MlLiteralBodyContext!): Unit

abstract fun enterMlLiteralString(ctx: MlLiteralStringContext!): Unit

abstract fun enterMonth(ctx: MonthContext!): Unit

abstract fun enterOctInt(ctx: OctIntContext!): Unit

abstract fun enterOffsetDateTime(ctx: OffsetDateTimeContext!): Unit

abstract fun enterQuotedKey(ctx: QuotedKeyContext!): Unit

abstract fun enterRegularFloat(ctx: RegularFloatContext!): Unit

abstract fun enterRegularFloatInf(ctx: RegularFloatInfContext!): Unit

abstract fun enterRegularFloatNaN(ctx: RegularFloatNaNContext!): Unit

abstract fun enterSecond(ctx: SecondContext!): Unit

abstract fun enterSecondFraction(ctx: SecondFractionContext!): Unit

abstract fun enterSimpleKey(ctx: SimpleKeyContext!): Unit

abstract fun enterStandardTable(ctx: StandardTableContext!): Unit

abstract fun enterString(ctx: StringContext!): Unit

abstract fun enterTable(ctx: TableContext!): Unit

abstract fun enterTime(ctx: TimeContext!): Unit

abstract fun enterTimeOffset(ctx: TimeOffsetContext!): Unit

abstract fun enterToml(ctx: TomlContext!): Unit

abstract fun enterTomlKey(ctx: TomlKeyContext!): Unit

abstract fun enterTrueBool(ctx: TrueBoolContext!): Unit

abstract fun enterUnquotedKey(ctx: UnquotedKeyContext!): Unit

abstract fun enterVal(ctx: ValContext!): Unit

abstract fun enterYear(ctx: YearContext!): Unit

abstract fun exitArray(ctx: ArrayContext!): Unit

abstract fun exitArrayTable(ctx: ArrayTableContext!): Unit

abstract fun exitArrayValue(ctx: ArrayValueContext!): Unit

abstract fun exitArrayValues(ctx: ArrayValuesContext!): Unit

abstract fun exitBasicChar(ctx: BasicCharContext!): Unit

abstract fun exitBasicString(ctx: BasicStringContext!): Unit

abstract fun exitBasicUnescaped(ctx: BasicUnescapedContext!): Unit

abstract fun exitBinInt(ctx: BinIntContext!): Unit

abstract fun exitBooleanValue(ctx: BooleanValueContext!): Unit

abstract fun exitDate(ctx: DateContext!): Unit

abstract fun exitDateTime(ctx: DateTimeContext!): Unit

abstract fun exitDay(ctx: DayContext!): Unit

abstract fun exitDecInt(ctx: DecIntContext!): Unit

abstract fun exitEscaped(ctx: EscapedContext!): Unit

abstract fun exitExpression(ctx: ExpressionContext!): Unit

abstract fun exitFalseBool(ctx: FalseBoolContext!): Unit

abstract fun exitFloatValue(ctx: FloatValueContext!): Unit

abstract fun exitHexInt(ctx: HexIntContext!): Unit

abstract fun exitHour(ctx: HourContext!): Unit

abstract fun exitHourOffset(ctx: HourOffsetContext!): Unit

abstract fun exitInlineTable(ctx: InlineTableContext!): Unit

abstract fun exitInlineTableValues(ctx: InlineTableValuesContext!): Unit

abstract fun exitInteger(ctx: IntegerContext!): Unit

abstract fun exitKey(ctx: KeyContext!): Unit

abstract fun exitKeyval(ctx: KeyvalContext!): Unit

abstract fun exitLiteralBody(ctx: LiteralBodyContext!): Unit

abstract fun exitLiteralString(ctx: LiteralStringContext!): Unit

abstract fun exitLocalDate(ctx: LocalDateContext!): Unit

abstract fun exitLocalDateTime(ctx: LocalDateTimeContext!): Unit

abstract fun exitLocalTime(ctx: LocalTimeContext!): Unit

abstract fun exitMinute(ctx: MinuteContext!): Unit

abstract fun exitMinuteOffset(ctx: MinuteOffsetContext!): Unit

abstract fun exitMlBasicChar(ctx: MlBasicCharContext!): Unit

abstract fun exitMlBasicString(ctx: MlBasicStringContext!): Unit

abstract fun exitMlBasicUnescaped(ctx: MlBasicUnescapedContext!): Unit

abstract fun exitMlLiteralBody(ctx: MlLiteralBodyContext!): Unit

abstract fun exitMlLiteralString(ctx: MlLiteralStringContext!): Unit

abstract fun exitMonth(ctx: MonthContext!): Unit

abstract fun exitOctInt(ctx: OctIntContext!): Unit

abstract fun exitOffsetDateTime(ctx: OffsetDateTimeContext!): Unit

abstract fun exitQuotedKey(ctx: QuotedKeyContext!): Unit

abstract fun exitRegularFloat(ctx: RegularFloatContext!): Unit

abstract fun exitRegularFloatInf(ctx: RegularFloatInfContext!): Unit

abstract fun exitRegularFloatNaN(ctx: RegularFloatNaNContext!): Unit

abstract fun exitSecond(ctx: SecondContext!): Unit

abstract fun exitSecondFraction(ctx: SecondFractionContext!): Unit

abstract fun exitSimpleKey(ctx: SimpleKeyContext!): Unit

abstract fun exitStandardTable(ctx: StandardTableContext!): Unit

abstract fun exitString(ctx: StringContext!): Unit

abstract fun exitTable(ctx: TableContext!): Unit

abstract fun exitTime(ctx: TimeContext!): Unit

abstract fun exitTimeOffset(ctx: TimeOffsetContext!): Unit

abstract fun exitToml(ctx: TomlContext!): Unit

abstract fun exitTomlKey(ctx: TomlKeyContext!): Unit

abstract fun exitTrueBool(ctx: TrueBoolContext!): Unit

abstract fun exitUnquotedKey(ctx: UnquotedKeyContext!): Unit

abstract fun exitVal(ctx: ValContext!): Unit

abstract fun exitYear(ctx: YearContext!): Unit

interface TomlParserVisitor<T : Any!> : ParseTreeVisitor<T>

Module Contents

abstract fun visitArray(ctx: ArrayContext!): T

abstract fun visitArrayTable(ctx: ArrayTableContext!): T

abstract fun visitArrayValue(ctx: ArrayValueContext!): T

abstract fun visitArrayValues(ctx: ArrayValuesContext!): T

abstract fun visitBasicChar(ctx: BasicCharContext!): T

abstract fun visitBasicString(ctx: BasicStringContext!): T

abstract fun visitBasicUnescaped(ctx: BasicUnescapedContext!): T

abstract fun visitBinInt(ctx: BinIntContext!): T

abstract fun visitBooleanValue(ctx: BooleanValueContext!): T

abstract fun visitDate(ctx: DateContext!): T

abstract fun visitDateTime(ctx: DateTimeContext!): T

abstract fun visitDay(ctx: DayContext!): T

abstract fun visitDecInt(ctx: DecIntContext!): T

abstract fun visitEscaped(ctx: EscapedContext!): T

abstract fun visitExpression(ctx: ExpressionContext!): T

abstract fun visitFalseBool(ctx: FalseBoolContext!): T

abstract fun visitFloatValue(ctx: FloatValueContext!): T

abstract fun visitHexInt(ctx: HexIntContext!): T

abstract fun visitHour(ctx: HourContext!): T

abstract fun visitHourOffset(ctx: HourOffsetContext!): T

abstract fun visitInlineTable(ctx: InlineTableContext!): T

abstract fun visitInlineTableValues(ctx: InlineTableValuesContext!): T

abstract fun visitInteger(ctx: IntegerContext!): T

abstract fun visitKey(ctx: KeyContext!): T

abstract fun visitKeyval(ctx: KeyvalContext!): T

abstract fun visitLiteralBody(ctx: LiteralBodyContext!): T

abstract fun visitLiteralString(ctx: LiteralStringContext!): T

abstract fun visitLocalDate(ctx: LocalDateContext!): T

abstract fun visitLocalDateTime(ctx: LocalDateTimeContext!): T

abstract fun visitLocalTime(ctx: LocalTimeContext!): T

abstract fun visitMinute(ctx: MinuteContext!): T

abstract fun visitMinuteOffset(ctx: MinuteOffsetContext!): T

abstract fun visitMlBasicChar(ctx: MlBasicCharContext!): T

abstract fun visitMlBasicString(ctx: MlBasicStringContext!): T

abstract fun visitMlBasicUnescaped(ctx: MlBasicUnescapedContext!): T

abstract fun visitMlLiteralBody(ctx: MlLiteralBodyContext!): T

abstract fun visitMlLiteralString(ctx: MlLiteralStringContext!): T

abstract fun visitMonth(ctx: MonthContext!): T

abstract fun visitOctInt(ctx: OctIntContext!): T

abstract fun visitOffsetDateTime(ctx: OffsetDateTimeContext!): T

abstract fun visitQuotedKey(ctx: QuotedKeyContext!): T

abstract fun visitRegularFloat(ctx: RegularFloatContext!): T

abstract fun visitRegularFloatInf(ctx: RegularFloatInfContext!): T

abstract fun visitRegularFloatNaN(ctx: RegularFloatNaNContext!): T

abstract fun visitSecond(ctx: SecondContext!): T

abstract fun visitSecondFraction(ctx: SecondFractionContext!): T

abstract fun visitSimpleKey(ctx: SimpleKeyContext!): T

abstract fun visitStandardTable(ctx: StandardTableContext!): T

abstract fun visitString(ctx: StringContext!): T

abstract fun visitTable(ctx: TableContext!): T

abstract fun visitTime(ctx: TimeContext!): T

abstract fun visitTimeOffset(ctx: TimeOffsetContext!): T

abstract fun visitToml(ctx: TomlContext!): T

abstract fun visitTomlKey(ctx: TomlKeyContext!): T

abstract fun visitTrueBool(ctx: TrueBoolContext!): T

abstract fun visitUnquotedKey(ctx: UnquotedKeyContext!): T

abstract fun visitVal(ctx: ValContext!): T

abstract fun visitYear(ctx: YearContext!): T

package org.apache.tuweni.trie

Module Contents

abstract class AsyncMerkleStorage :

open suspend fun get(hash:

Module Contents

AsyncMerkleStorage()

)

abstract fun getAsync(hash:

)

open suspend fun put(hash:

content

abstract fun putAsync(hash:

)

Unit

content

)

static fun bytesToPath(bytes:

class CompactEncoding

Module Contents

)

static fun decode(encoded:

)

static fun encode(path:

)

static val LEAF_TERMINATOR: Byte

class MerklePatriciaTrie<V> :

MerklePatriciaTrie(valueSerializer: (V) ->

Module Contents

@JvmStatic fun <V> create(valueSerializer: Function<V,

)

)

)

)

value

)

Unit

fun putAsync(key:

value

)

@JvmStatic fun storingBytes():

)

Unit

)

@JvmStatic fun storingStrings():

String

interface MerkleStorage

Module Contents

)

abstract suspend fun put(hash:

content

class MerkleStorageException : RuntimeException

)

Unit

Module Contents

MerkleStorageException(message: String)

MerkleStorageException(message: String, cause: Exception)

interface MerkleTrie<in K, V>

Module Contents

val EMPTY_TRIE_ROOT_HASH:

open fun getAsync(dispatcher: CoroutineDispatcher, key: K):

abstract suspend fun put(key: K, value: V?): Unit

open fun putAsync(key: K, value: V?):

open fun putAsync(dispatcher: CoroutineDispatcher, key: K, value: V?):

abstract suspend fun remove(key: K): Unit

open fun removeAsync(key: K):

open fun removeAsync(dispatcher: CoroutineDispatcher, key: K):

abstract fun rootHash():

class StoredMerklePatriciaTrie<V> :

Module Contents

valueSerializer

(

)

valueDeserializer

(

)

rootHash

valueSerializer

(

)

valueDeserializer

(

)

fun clearCache(): Unit

valueSerializer

Function

valueDeserializer

Function

)

rootHash

valueSerializer

Function

valueDeserializer

Function

)

)

value

)

Unit

)

Unit

fun rootHash():

)

rootHash

)

)

String

rootHash

)

String

package org.apache.tuweni.units.bigints

Module Contents

abstract class BaseUInt256Value<T :

protected BaseUInt256Value(value:

Module Contents

ctor

Function

protected BaseUInt256Value(value: Long, ctor: Function<

)

protected BaseUInt256Value(value: BigInteger!, ctor: Function<

)

)

)

)

modulus

)

)

)

Int

)

open fun divideCeil(value: T): T

open fun divideCeil(value:

open fun divideCeil(value: Long): T

)

)

open fun mod0(modulus:

open fun mod0(modulus: Long): T

)

)

)

modulus

)

open fun multiplyMod(value: Long, modulus: Long): T

)

)

)

open fun toUInt256():

abstract class BaseUInt32Value<T :

protected BaseUInt32Value(value:

Module Contents

ctor

Function

protected BaseUInt32Value(value: Int, ctor: Function<

)

protected BaseUInt32Value(value: BigInteger!, ctor: Function<

)

)

open fun add(value: Int): T

)

)

modulus

)

)

)

Int

open fun divide(value: Int): T

)

open fun mod(modulus: Int): T

)

open fun multiply(value: Int): T

)

)

modulus

open fun multiplyMod(value: Int, modulus:

)

open fun multiplyMod(value: Int, modulus: Int): T

)

)

open fun subtract(value: Int): T

)

open fun toUInt32():

abstract class BaseUInt384Value<T :

protected BaseUInt384Value(value:

Module Contents

ctor

Function

protected BaseUInt384Value(value: Long, ctor: Function<

)

protected BaseUInt384Value(value: BigInteger!, ctor: Function<

)

)

)

)

modulus

)

)

)

Int

)

)

)

)

modulus

)

open fun multiplyMod(value: Long, modulus: Long): T

)

)

)

open fun toUInt384():

abstract class BaseUInt64Value<T :

protected BaseUInt64Value(value:

Module Contents

ctor

Function

protected BaseUInt64Value(value: Long, ctor: Function<

)

protected BaseUInt64Value(value: BigInteger!, ctor: Function<

)

)

)

)

modulus

)

)

)

Int

)

)

)

)

modulus

)

open fun multiplyMod(value: Long, modulus: Long): T

)

)

)

open fun toUInt64():

Module Contents

)

modulus

)

)

)

)

)

Int

)

fun divideCeil(value:

)

fun divideCeil(value: Long):

)

)

)

fun mod0(modulus: Long):

)

modulus

)

)

)

)

)

)

fun toUInt256():

)

)

Module Contents

max

(

)

interface UInt256Value<T :

min

(

)

Comparable

Module Contents

)

)

abstract fun divideCeil(value: T): T

abstract fun divideCeil(value: Long): T

)

abstract fun mod0(modulus:

abstract fun mod0(modulus: Long): T

)

)

abstract fun multiplyMod(value: Long, modulus: Long): T

)

open fun plus(value: T): T

open fun plus(value: Long): T

)

abstract fun toUInt256():

Module Contents

)

modulus

)

)

)

)

)

Int

)

fun divide(value: Int):

)

byteOrder

ByteOrder

)

fun multiply(value: Int):

)

fun mod(modulus: Int):

)

modulus

)

fun multiplyMod(value: Int, modulus:

)

fun multiplyMod(value: Int, modulus: Int):

)

)

)

fun subtract(value: Int):

)

fun toUInt32():

static fun valueOf(value: Int):

)

)

Module Contents

max

(

)

interface UInt32Value<T :

min

(

)

Comparable

Module Contents

abstract fun add(value: Int): T

open fun addExact(value: Int): T

)

)

abstract fun divide(value: Int): T

abstract fun mod(modulus: Int): T

)

abstract fun multiply(value: Int): T

abstract fun multiplyMod(value: Int, modulus:

)

abstract fun multiplyMod(value: Int, modulus: Int): T

)

)

abstract fun subtract(value: Int): T

open fun subtractExact(value: Int): T

abstract fun toUInt32():

Module Contents

)

modulus

)

)

)

)

)

Int

)

)

)

)

modulus

)

)

)

)

)

)

fun toUInt384():

)

)

Module Contents

max

(

)

interface UInt384Value<T :

min

(

)

Comparable

Module Contents

)

)

)

)

abstract fun multiplyMod(value: Long, modulus: Long): T

)

)

abstract fun toUInt384():

Module Contents

)

modulus

)

)

)

)

)

Int

)

)

)

)

modulus

)

)

)

)

)

static fun random():

)

fun toUInt64():

)

)

Module Contents

max

(

)

interface UInt64Value<T :

min

(

)

Comparable

Module Contents

)

)

)

)

abstract fun multiplyMod(value: Long, modulus: Long): T

)

)

abstract fun toUInt64():

package org.apache.tuweni.units.ethereum

Module Contents

Module Contents

)

fun compareTo(other: Long): Int

fun priceFor(gasPrice:

)

)

static fun fromEth(ethValue: Long):

Module Contents

)

package org.apache.tuweni.wallet

Module Contents

class Wallet

Module Contents

Wallet(file: Path, password: String)

fun address():

fun create(file: Path, password: String):

fun open(file: Path, password: String):

gasPrice

gasLimit

value

payload

chainId

Int

)

fun verify(tx: